(no commit message)
[utils] / system / spring / src / test / java / org / wamblee / system / spring / SpringComponentTest.java
index 0b4ffb08a9f83eb497f3cf4a73ded1bcb4de1906..c63916f5d68946a6c3d0baa5a004d11b8d3322b8 100644 (file)
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2007 the original author or authors.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.wamblee.system.spring;
 
 import java.io.IOException;
@@ -8,20 +23,20 @@ import java.util.Properties;
 import junit.framework.TestCase;
 
 import org.wamblee.io.ClassPathResource;
-import org.wamblee.system.DefaultProvidedInterfaceDescriptor;
-import org.wamblee.system.DefaultRequiredInterfaceDescriptor;
-import org.wamblee.system.DefaultService;
-import org.wamblee.system.ProvidedInterface;
-import org.wamblee.system.RequiredInterface;
-import org.wamblee.system.Service;
-import org.wamblee.system.SystemAssemblyException;
+import org.wamblee.system.core.DefaultProvidedInterface;
+import org.wamblee.system.core.DefaultRequiredInterface;
+import org.wamblee.system.core.DefaultScope;
+import org.wamblee.system.core.ProvidedInterface;
+import org.wamblee.system.core.RequiredInterface;
+import org.wamblee.system.core.Scope;
+import org.wamblee.system.core.SystemAssemblyException;
 
 public class SpringComponentTest extends TestCase {
 
        private static final String HELLO_SERVICE_SPRING_XML = "test.org.wamblee.system.spring.xml";
        private static final String HELLO_SERVICE_SPRING_WITH_REQS_XML = "test.org.wamblee.system.springWithRequirements.xml";
        private static final String HELLO_SERVICE_SPRING_WITH_PROPERTIES_XML = "test.org.wamblee.system.springWithProperties.xml";
-    private static final String PROPERTY_FILE = "test.org.wamblee.system.spring.properties";
+       private static final String PROPERTY_FILE = "test.org.wamblee.system.spring.properties";
 
        @Override
        protected void setUp() throws Exception {
@@ -33,46 +48,43 @@ public class SpringComponentTest extends TestCase {
                                new String[] { HELLO_SERVICE_SPRING_XML },
                                new HashMap<String, ProvidedInterface>(),
                                new HashMap<RequiredInterface, String>());
-               system.start("Hello");
-               ProvidedInterface[] services = system.getRunningServices();
-               assertEquals(0, services.length);
-               
-               system.stop();
+               Scope runtime = system.start();
+               assertEquals(0, runtime.getProvidedInterfaces().length);
+
+               system.stop(runtime);
        }
 
        public void testOneProvidedService() {
                Map<String, ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
-               provided.put("helloService", new DefaultProvidedInterfaceDescriptor(
-                               "hello", HelloService.class));
+               provided.put("helloService", new DefaultProvidedInterface("hello",
+                               HelloService.class));
 
-               SpringComponent system = new SpringComponent("system", 
+               SpringComponent system = new SpringComponent("system",
                                new String[] { HELLO_SERVICE_SPRING_XML }, provided,
                                new HashMap<RequiredInterface, String>());
-               system.start("Hello");
-               ProvidedInterface[] services = system.getRunningServices();
+               Scope runtime = system.start();
+               ProvidedInterface[] services = runtime.getProvidedInterfaces();
                assertEquals(1, services.length);
-               assertTrue(services[0].getImplementation() instanceof HelloService);
-               assertEquals("Hello world!", ((HelloService)services[0].getImplementation())
-                               .say());
-               system.stop();
+               Object service = runtime.getInterfaceImplementation(services[0], Object.class);
+               assertTrue(service instanceof HelloService);
+               assertEquals("Hello world!", ((HelloService) service).say());
+               system.stop(runtime);
        }
-       
+
        public void testWithProperties() throws IOException {
                Map<String, ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
-               provided.put("helloService", new DefaultProvidedInterfaceDescriptor(
-                               "hello", HelloService.class));
-               SpringComponent system = new SpringComponent("system", 
+               provided.put("helloService", new DefaultProvidedInterface("hello",
+                               HelloService.class));
+               SpringComponent system = new SpringComponent("system",
                                new String[] { HELLO_SERVICE_SPRING_WITH_PROPERTIES_XML },
-                               provided,
-                               new HashMap<RequiredInterface, String>());
+                               provided, new HashMap<RequiredInterface, String>());
                Properties props = new Properties();
                props.load(new ClassPathResource(PROPERTY_FILE).getInputStream());
                system.addProperties(props);
-               
-               system.start("Hello");
-               ProvidedInterface[] services = system.getRunningServices();
-               assertEquals("Property Value", 
-                               ((HelloService)services[0].getImplementation()).say());
+
+               Scope scope = system.start();
+               ProvidedInterface[] services = scope.getProvidedInterfaces();
+               assertEquals("Property Value", scope.getInterfaceImplementation(services[0], HelloService.class).say());
        }
 
        public void testWithMissingRequirement() {
@@ -81,9 +93,9 @@ public class SpringComponentTest extends TestCase {
                                        new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
                                        new HashMap<String, ProvidedInterface>(),
                                        new HashMap<RequiredInterface, String>());
-                       system.start("Bla");
+                       system.start();
                } catch (SystemAssemblyException e) {
-                       //e.printStackTrace();
+                       // e.printStackTrace();
                        return;
                }
                fail();
@@ -91,46 +103,49 @@ public class SpringComponentTest extends TestCase {
 
        public void testWithRequirement() {
                Map<RequiredInterface, String> required = new HashMap<RequiredInterface, String>();
-               required.put(new DefaultRequiredInterfaceDescriptor("hello", HelloService.class),
+               required.put(new DefaultRequiredInterface("hello", HelloService.class),
                                "helloService");
                SpringComponent system = new SpringComponent("system",
                                new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
                                new HashMap<String, ProvidedInterface>(), required);
-               
-               HelloService helloObject = new HelloService("ladida"); 
-               ProvidedInterface helloService = new DefaultProvidedInterfaceDescriptor("hello", HelloService.class);
-               helloService.publish(helloObject);
-               system.getRequiredServices()[0].setProvider(helloService);
-               
-               system.start("Bla");
-               system.stop();
+
+               HelloService helloObject = new HelloService("ladida");
+               ProvidedInterface helloService = new DefaultProvidedInterface("hello",
+                               HelloService.class);
+               Scope scope = new DefaultScope(new ProvidedInterface[]{ helloService });
+               scope.publishInterface(helloService, helloObject);
+               system.getRequiredInterfaces()[0].setProvider(helloService);
+
+               Scope runtime = system.start(scope);
+               system.stop(runtime);
        }
-       
+
        public void testWithRequirementAndProvidedService() {
                Map<RequiredInterface, String> required = new HashMap<RequiredInterface, String>();
-               required.put(new DefaultRequiredInterfaceDescriptor("hello", HelloService.class),
+               required.put(new DefaultRequiredInterface("hello", HelloService.class),
                                "helloService");
-               Map<String,ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
-               provided.put("blaService", new DefaultProvidedInterfaceDescriptor("bla",
+               Map<String, ProvidedInterface> provided = new HashMap<String, ProvidedInterface>();
+               provided.put("blaService", new DefaultProvidedInterface("bla",
                                BlaService.class));
 
                SpringComponent system = new SpringComponent("system",
-                               new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML },
-                               provided, required);
-               
-               HelloService helloObject = new HelloService("ladida"); 
-               ProvidedInterface helloService = 
-                       new DefaultProvidedInterfaceDescriptor("hello", HelloService.class);
-               helloService.publish(helloObject);
-               system.getRequiredServices()[0].setProvider(helloService);
-               system.start("Bla");
-               ProvidedInterface started = system.getProvidedServices()[0];
-               
-           assertNotNull(started.getImplementation());
-           assertTrue(started.getImplementation() instanceof BlaService);
-               assertEquals("ladida", 
-                               ((BlaService)started.getImplementation()).execute());
-               system.stop();
+                               new String[] { HELLO_SERVICE_SPRING_WITH_REQS_XML }, provided,
+                               required);
+
+               HelloService helloObject = new HelloService("ladida");
+               ProvidedInterface helloService = new DefaultProvidedInterface("hello",
+                               HelloService.class);
+               Scope scope = new DefaultScope(new ProvidedInterface[] {  helloService });
+               scope.publishInterface(helloService, helloObject);
+               system.getRequiredInterfaces()[0].setProvider(helloService);
+               Scope runtime = system.start(scope);
+               ProvidedInterface started = runtime.getProvidedInterfaces()[0];
+
+               Object impl = runtime.getInterfaceImplementation(started, BlaService.class);
+               assertNotNull(impl);
+               assertTrue(impl instanceof BlaService);
+               assertEquals("ladida", ((BlaService)impl).execute());
+               system.stop(runtime);
        }
 
 }