diff options
Diffstat (limited to 'sca-java-1.x/tags/java-M1-20060522/java/sca/core/src/test/java/org/apache/tuscany/core/config/impl/CoreAnnotationsProcessingTestCase.java')
-rw-r--r-- | sca-java-1.x/tags/java-M1-20060522/java/sca/core/src/test/java/org/apache/tuscany/core/config/impl/CoreAnnotationsProcessingTestCase.java | 173 |
1 files changed, 173 insertions, 0 deletions
diff --git a/sca-java-1.x/tags/java-M1-20060522/java/sca/core/src/test/java/org/apache/tuscany/core/config/impl/CoreAnnotationsProcessingTestCase.java b/sca-java-1.x/tags/java-M1-20060522/java/sca/core/src/test/java/org/apache/tuscany/core/config/impl/CoreAnnotationsProcessingTestCase.java new file mode 100644 index 0000000000..aeb614e9c6 --- /dev/null +++ b/sca-java-1.x/tags/java-M1-20060522/java/sca/core/src/test/java/org/apache/tuscany/core/config/impl/CoreAnnotationsProcessingTestCase.java @@ -0,0 +1,173 @@ +/** + * + * Copyright 2005 The Apache Software Foundation or its licensors, as applicable. + * + * 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.apache.tuscany.core.config.impl; + +import java.util.List; + +import junit.framework.TestCase; +import org.apache.tuscany.core.config.ComponentTypeIntrospector; +import org.apache.tuscany.core.config.JavaIntrospectionHelper; +import org.apache.tuscany.core.config.processor.ProcessorUtils; +import org.apache.tuscany.core.system.assembly.impl.SystemAssemblyFactoryImpl; +import org.apache.tuscany.model.assembly.AssemblyFactory; +import org.apache.tuscany.model.assembly.ComponentType; +import org.apache.tuscany.model.assembly.Multiplicity; +import org.apache.tuscany.model.assembly.Reference; +import org.apache.tuscany.model.assembly.Scope; +import org.apache.tuscany.model.assembly.Service; +import org.apache.tuscany.model.assembly.ServiceContract; + +/** + * @version $$Rev$$ $$Date$$ + */ +public class CoreAnnotationsProcessingTestCase extends TestCase { + + private ComponentTypeIntrospector introspector; + private AssemblyFactory factory; + + public void testServiceBasicProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestComponentImpl.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(TestComponent.class, contract.getInterface()); + assertEquals(Scope.MODULE, contract.getScope()); + } + + public void testServiceNameSet() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestComponentImpl.class, type); + assertEquals(1, type.getServices().size()); + Service service = type.getServices().get(0); + assertEquals(JavaIntrospectionHelper.getBaseName(TestComponent.class), service.getName()); + } + + /** + * Tests the case where a class implements one interface not marked as with <code>Remotable</code> + */ + public void testSingleServiceProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestLocalComponentImpl.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(TestLocalComponent.class, contract.getInterface()); + assertEquals(Scope.MODULE, contract.getScope()); + } + + /** + * Tests the case where an implementation specifies a service interface of its parent as opposed to the + * single interface it directly implements + */ + public void testInteraceHierarchyServiceProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(SuperFooImpl.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(SuperSuperFoo.class, contract.getInterface()); + } + + /** + * Tests the case where a class implements two interfaces, with one specified using <code>@Service</code> + * and one marked with <code>@Remotable</code> + */ + public void testMutlipleServiceProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestMultipleInterfacesComponentImpl.class, type); + assertEquals(2, type.getServices().size()); + for (Service service : type.getServices()) { + if (!service.getServiceContract().equals(TestComponent.class) && + service.getServiceContract().equals(TestLocalComponent.class)) { + fail("Expected multiple interfaces not found"); + } + } + } + + /** + * Test case when an class implements two non-Remotable interfaces and does not specify one with + * <code>@Service</code> + */ + public void testNonServiceProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestNonServiceInterfacesImpl.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(TestNonServiceInterfacesImpl.class, contract.getInterface()); + assertEquals(Scope.MODULE, contract.getScope()); + } + + /** + * Tests the case where a class implements two non-Remotable interfaces, with one specified using + * <code>@Service</code> + */ + public void testNonServiceSpecifiedProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestNonServiceSpecifiedImpl.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(TestNonServiceInterface.class, contract.getInterface()); + assertEquals(Scope.MODULE, contract.getScope()); + } + + /** + * Tests the case where a component's scope is specified by its superclass + */ + public void testParentScopeEvaluation() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(ScopeTestComponent.class, type); + assertEquals(1, type.getServices().size()); + ServiceContract contract = type.getServices().get(0).getServiceContract(); + assertEquals(Scope.MODULE, contract.getScope()); + } + + /** + * FIXME JFM - temporarily disabled until non-annotated properties are fixed public void + * testPropertyProcessing() throws Exception { ComponentType type = factory.createComponentType(); + * introspector.introspect(TestComponentImpl.class, type); List<Property>properties = + * type.getProperties(); assertEquals(3, properties.size()); for (Property property : properties) { if + * (!property.getName().equals("foo") && !property.getName().equals("fooRequired") && + * !property.getName().equals("baz")) { fail("Property names not handled properly"); } if + * (property.getName().equals("fooRequired")) { assertTrue(property.isRequired()); } else { + * assertFalse(property.isRequired()); } } } * + */ + + public void testReferenceProcessing() throws Exception { + ComponentType type = factory.createComponentType(); + introspector.introspect(TestComponentImpl.class, type); + List<Reference>references = type.getReferences(); + assertEquals(5, references.size()); + for (Reference reference : references) { + if (reference.getName().equals("setBarRequired")) { + assertTrue(reference.getMultiplicity() == Multiplicity.ONE_N); + } else if (reference.getName().equals("setBar")) { + assertTrue(reference.getMultiplicity() == Multiplicity.ZERO_N); + } else if (reference.getName().equals("bazRefeference")) { + assertTrue(reference.getMultiplicity() == Multiplicity.ZERO_ONE); + } else if (reference.getName().equals("wombat")) { + assertTrue(reference.getMultiplicity() == Multiplicity.ONE_ONE); + } else if (reference.getName().equals("bar")) { + assertTrue(reference.getMultiplicity() == Multiplicity.ZERO_ONE); + } else { + fail("Reference names not handled properly"); + } + } + } + + + protected void setUp() throws Exception { + super.setUp(); + factory = new SystemAssemblyFactoryImpl(); + introspector = ProcessorUtils.createCoreIntrospector(factory); + } + +} |