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