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