wamblee.org Git - utils/blob - system/general/src/test/java/org/wamblee/system/SystemAssemblerTest.java

   1 package org.wamblee.system;
   2
   3 import java.io.Serializable;
   4 import java.util.ArrayList;
   5 import java.util.Arrays;
   6
   7 import org.wamblee.test.AssertionUtils;
   8
   9 import junit.framework.TestCase;
  10
  11 public class SystemAssemblerTest extends TestCase {
  12
  13         private ServiceRegistry _registry;
  14
  15         @Override
  16         protected void setUp() throws Exception {
  17                 super.setUp();
  18                 _registry = new DefaultServiceRegistry();
  19         }
  20
  21         private static class MyMultiple implements Serializable, Runnable {
  22                 @Override
  23                 public void run() {
  24                         // Empty
  25                 }
  26         }
  27
  28         public void testFilterProvided() {
  29                 RequiredInterfaceDescriptor req1 = new DefaultRequiredInterfaceDescriptor(
  30                                 "name", Runnable.class);
  31                 RequiredInterfaceDescriptor req2 = new DefaultRequiredInterfaceDescriptor(
  32                                 "name", Serializable.class);
  33                 ProvidedInterfaceDescriptor prov1 = new DefaultProvidedInterfaceDescriptor(
  34                                 "name", Runnable.class);
  35                 ProvidedInterfaceDescriptor prov2 = new DefaultProvidedInterfaceDescriptor(
  36                                 "name", Serializable.class);
  37                 ProvidedInterfaceDescriptor prov3 = new DefaultProvidedInterfaceDescriptor(
  38                                 "name", MyMultiple.class);
  39
  40                 AssertionUtils.assertEquals(new RequiredInterfaceDescriptor[] { req1 },
  41                                 SystemAssembler.filterRequiredServices(prov1, Arrays
  42                                                 .asList(new RequiredInterfaceDescriptor[] { req1 })));
  43                 AssertionUtils.assertEquals(new RequiredInterfaceDescriptor[] { req1 },
  44                                 SystemAssembler
  45                                                 .filterRequiredServices(prov1, Arrays
  46                                                                 .asList(new RequiredInterfaceDescriptor[] { req1,
  47                                                                                 req2 })));
  48                 AssertionUtils.assertEquals(new RequiredInterfaceDescriptor[] { req1,
  49                                 req2 }, SystemAssembler.filterRequiredServices(prov3, Arrays
  50                                 .asList(new RequiredInterfaceDescriptor[] { req1, req2 })));
  51
  52                 AssertionUtils.assertEquals(new ProvidedInterfaceDescriptor[] { prov1 },
  53                                 SystemAssembler.filterProvidedServices(req1, Arrays
  54                                                 .asList(new ProvidedInterfaceDescriptor[] { prov1 })));
  55                 AssertionUtils.assertEquals(new ProvidedInterfaceDescriptor[] { prov1 },
  56                                 SystemAssembler.filterProvidedServices(req1,
  57                                                 Arrays.asList(new ProvidedInterfaceDescriptor[] { prov1,
  58                                                                 prov2 })));
  59                 AssertionUtils.assertEquals(new ProvidedInterfaceDescriptor[] { prov1,
  60                                 prov3 }, SystemAssembler.filterProvidedServices(req1, Arrays
  61                                 .asList(new ProvidedInterfaceDescriptor[] { prov1, prov3 })));
  62         }
  63
  64         public void testEnvironmentApplication() {
  65                 Component environment = new Environment(_registry);
  66                 Component application = new Application(_registry);
  67                 SystemAssembler assembler = new SystemAssembler(new Component[] {
  68                                 environment, application }, new ProvidedInterfaceDescriptor[0]);
  69                 assembler.start(_registry, new Service[0]);
  70                 Service[] envServices = environment.getRunningServices();
  71                 assertEquals(2, envServices.length);
  72                 Service[] appServices = environment.getRunningServices();
  73                 assertEquals(2, appServices.length);
  74                 assertEquals(2, _registry.listAllServices().length);
  75
  76                 environment.stop();
  77                 assertEquals(0, _registry.listAllServices().length);
  78
  79                 application.stop();
  80                 assertEquals(0, _registry.listAllServices().length);
  81         }
  82
  83         public void testApplicationEnvironment() {
  84                 try {
  85                         Component environment = new Environment(_registry);
  86                         Component application = new Application(_registry);
  87                         SystemAssembler assembler = new SystemAssembler(new Component[] {
  88                                         application, environment },
  89                                         new ProvidedInterfaceDescriptor[0]);
  90                         assembler.start(_registry, new Service[0]);
  91                 } catch (SystemAssemblyException e) {
  92                         // e.printStackTrace();
  93                         return;
  94                 }
  95                 fail();
  96         }
  97
  98         public void testComposite() {
  99                 Component environment = new Environment(_registry);
 100                 Component application = new Application(_registry);
 101                 CompositeSystem system = new CompositeSystem("all", _registry,
 102                                 new Component[] { environment, application },
 103                                 new InterfaceDescriptor[0], new InterfaceDescriptor[0]);
 104                 system.start("root", new Service[0]);
 105                 InterfaceDescriptor[] required = system.getRequiredServices();
 106                 assertEquals(0, required.length);
 107                 InterfaceDescriptor[] provided = system.getProvidedServices();
 108                 assertEquals(0, provided.length);
 109         }
 110
 111         public void testCompositeWithWrongProvidedInfo() {
 112                 try {
 113                         Component environment = new Environment(_registry);
 114                         Component application = new Application(_registry);
 115                         CompositeSystem system = new CompositeSystem(
 116                                         "all",
 117                                         _registry,
 118                                         new Component[] { environment, application },
 119                                         new InterfaceDescriptor[] { new DefaultProvidedInterfaceDescriptor(
 120                                                         "string", String.class) },
 121                                         new DefaultRequiredInterfaceDescriptor[0]);
 122                 } catch (SystemAssemblyException e) {
 123                         return;
 124                 }
 125                 fail();
 126         }
 127
 128         public void testCompositeWithSuperfluousRequiredInfo() {
 129                 Component environment = new Environment(_registry);
 130                 Component application = new Application(_registry);
 131                 CompositeSystem system = new CompositeSystem("all", _registry,
 132                                 new Component[] { environment, application },
 133                                 new InterfaceDescriptor[0],
 134                                 new InterfaceDescriptor[] { new DefaultRequiredInterfaceDescriptor(
 135                                                 "string", String.class) });
 136                 system.start("root", new Service[0]);
 137                 InterfaceDescriptor[] required = system.getRequiredServices();
 138                 assertEquals(1, required.length);
 139                 InterfaceDescriptor[] provided = system.getProvidedServices();
 140                 assertEquals(0, provided.length);
 141         }
 142
 143         public void testCompositeWithExternalDependencesNotProvided() {
 144                 try {
 145                         Component environment = new Environment(_registry);
 146                         Component application = new Application(_registry);
 147                         CompositeSystem system = new CompositeSystem("all", _registry,
 148                                         new Component[] { application }, new InterfaceDescriptor[0],
 149                                         application.getRequiredServices());
 150                         system.start("root", new Service[0]);
 151                 } catch (SystemAssemblyException e) {
 152                         return;
 153                 }
 154                 fail();
 155
 156         }
 157
 158         public void testCompositeWithExternalDependencesProvided() {
 159
 160                 Component environment = new Environment(_registry);
 161                 Component application = new Application(_registry);
 162                 CompositeSystem system = new CompositeSystem("all", _registry,
 163                                 new Component[] { application }, new InterfaceDescriptor[0],
 164                                 application.getRequiredServices());
 165                 Service[] envServices = environment.start("env", new Service[0]);
 166                 system.start("root", envServices);
 167                 InterfaceDescriptor[] required = system.getRequiredServices();
 168                 assertEquals(2, required.length);
 169                 InterfaceDescriptor[] provided = system.getProvidedServices();
 170                 assertEquals(0, provided.length);
 171
 172         }
 173
 174         public void testAmbiguousInterfaces() {
 175                 try {
 176                         Component environment1 = new Environment(_registry);
 177                         Component environment2 = new Environment(_registry);
 178                         Component application = new Application(_registry);
 179                         SystemAssembler assembler = new SystemAssembler(new Component[] {
 180                                         environment1, environment2, application },
 181                                         new ProvidedInterfaceDescriptor[0]);
 182                         assembler.start(_registry, new Service[0]);
 183
 184                 } catch (SystemAssemblyException e) {
 185                         return;
 186                 }
 187                 fail();
 188         }
 189
 190
 191 }