http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmKeyPropertyRefImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmKeyPropertyRefImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmKeyPropertyRefImplTest.java new file mode 100644 index 0000000..00b2fc5 --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmKeyPropertyRefImplTest.java @@ -0,0 +1,141 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.olingo.commons.api.edm.EdmComplexType; +import org.apache.olingo.commons.api.edm.EdmElement; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmKeyPropertyRef; +import org.apache.olingo.commons.api.edm.EdmProperty; +import org.apache.olingo.commons.api.edm.provider.CsdlPropertyRef; +import org.apache.olingo.commons.core.edm.EdmKeyPropertyRefImpl; +import org.junit.Test; + +public class EdmKeyPropertyRefImplTest { + + @Test + public void noAlias() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("Id"); + EdmEntityType etMock = mock(EdmEntityType.class); + EdmProperty keyPropertyMock = mock(EdmProperty.class); + when(etMock.getStructuralProperty("Id")).thenReturn(keyPropertyMock); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(etMock, providerRef); + assertEquals("Id", ref.getName()); + assertNull(ref.getAlias()); + + EdmProperty property = ref.getProperty(); + assertNotNull(property); + assertTrue(property == keyPropertyMock); + assertTrue(property == ref.getProperty()); + } + + @Test + public void aliasForPropertyInComplexPropertyOneLevel() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("comp/Id").setAlias("alias"); + EdmEntityType etMock = mock(EdmEntityType.class); + EdmProperty keyPropertyMock = mock(EdmProperty.class); + EdmProperty compMock = mock(EdmProperty.class); + EdmComplexType compTypeMock = mock(EdmComplexType.class); + when(compTypeMock.getStructuralProperty("Id")).thenReturn(keyPropertyMock); + when(compMock.getType()).thenReturn(compTypeMock); + when(etMock.getStructuralProperty("comp")).thenReturn(compMock); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(etMock, providerRef); + assertEquals("alias", ref.getAlias()); + + EdmProperty property = ref.getProperty(); + assertNotNull(property); + assertTrue(property == keyPropertyMock); + } + + @Test(expected = EdmException.class) + public void aliasForPropertyInComplexPropertyButWrongPath() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("comp/wrong").setAlias("alias"); + EdmEntityType etMock = mock(EdmEntityType.class); + EdmProperty keyPropertyMock = mock(EdmProperty.class); + EdmElement compMock = mock(EdmProperty.class); + EdmComplexType compTypeMock = mock(EdmComplexType.class); + when(compTypeMock.getProperty("Id")).thenReturn(keyPropertyMock); + when(compMock.getType()).thenReturn(compTypeMock); + when(etMock.getProperty("comp")).thenReturn(compMock); + new EdmKeyPropertyRefImpl(etMock, providerRef).getProperty(); + } + + @Test(expected = EdmException.class) + public void aliasForPropertyInComplexPropertyButWrongPath2() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("wrong/Id").setAlias("alias"); + EdmEntityType etMock = mock(EdmEntityType.class); + EdmProperty keyPropertyMock = mock(EdmProperty.class); + EdmElement compMock = mock(EdmProperty.class); + EdmComplexType compTypeMock = mock(EdmComplexType.class); + when(compTypeMock.getProperty("Id")).thenReturn(keyPropertyMock); + when(compMock.getType()).thenReturn(compTypeMock); + when(etMock.getProperty("comp")).thenReturn(compMock); + new EdmKeyPropertyRefImpl(etMock, providerRef).getProperty(); + } + + @Test + public void aliasForPropertyInComplexPropertyTwoLevels() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("comp/comp2/Id").setAlias("alias"); + EdmEntityType etMock = mock(EdmEntityType.class); + EdmProperty keyPropertyMock = mock(EdmProperty.class); + EdmProperty compMock = mock(EdmProperty.class); + EdmComplexType compTypeMock = mock(EdmComplexType.class); + EdmProperty comp2Mock = mock(EdmProperty.class); + EdmComplexType comp2TypeMock = mock(EdmComplexType.class); + when(comp2TypeMock.getStructuralProperty("Id")).thenReturn(keyPropertyMock); + when(comp2Mock.getType()).thenReturn(comp2TypeMock); + when(compTypeMock.getStructuralProperty("comp2")).thenReturn(comp2Mock); + when(compMock.getType()).thenReturn(compTypeMock); + when(etMock.getStructuralProperty("comp")).thenReturn(compMock); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(etMock, providerRef); + + EdmProperty property = ref.getProperty(); + assertNotNull(property); + assertTrue(property == keyPropertyMock); + } + + @Test(expected = EdmException.class) + public void oneKeyNoAliasButInvalidProperty() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("Id"); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(mock(EdmEntityType.class), providerRef); + ref.getProperty(); + } + + @Test(expected = EdmException.class) + public void aliasButNoPath() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("Id").setAlias("alias"); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(mock(EdmEntityType.class), providerRef); + ref.getProperty(); + } + + @Test(expected = EdmException.class) + public void aliasButEmptyPath() { + CsdlPropertyRef providerRef = new CsdlPropertyRef().setName("").setAlias("alias"); + EdmKeyPropertyRef ref = new EdmKeyPropertyRefImpl(mock(EdmEntityType.class), providerRef); + ref.getProperty(); + } +}
http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMappingTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMappingTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMappingTest.java new file mode 100644 index 0000000..c284edf --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMappingTest.java @@ -0,0 +1,72 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +import java.util.Date; + +import org.apache.olingo.commons.api.edm.EdmParameter; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.EdmProperty; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlMapping; +import org.apache.olingo.commons.api.edm.provider.CsdlParameter; +import org.apache.olingo.commons.api.edm.provider.CsdlProperty; +import org.apache.olingo.commons.core.edm.EdmParameterImpl; +import org.apache.olingo.commons.core.edm.EdmPropertyImpl; +import org.junit.Test; + +public class EdmMappingTest { + + @Test + public void initialMappingMustBeNull() { + CsdlProperty property = new CsdlProperty().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()); + EdmProperty edmProperty = new EdmPropertyImpl(null, new FullQualifiedName("namespace.name"), property); + + assertNull(edmProperty.getMapping()); + + CsdlParameter parameter = new CsdlParameter().setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()); + EdmParameter edmParameter = new EdmParameterImpl(null, parameter); + + assertNull(edmParameter.getMapping()); + } + + @Test + public void getDataClassForPrimTypeViaMapping() { + CsdlMapping mapping = new CsdlMapping().setMappedJavaClass(Date.class); + CsdlProperty property = new CsdlProperty() + .setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()) + .setMapping(mapping); + EdmProperty edmProperty = new EdmPropertyImpl(null, new FullQualifiedName("namespace.name"), property); + + assertNotNull(edmProperty.getMapping()); + assertEquals(Date.class, edmProperty.getMapping().getMappedJavaClass()); + + CsdlParameter parameter = new CsdlParameter() + .setType(EdmPrimitiveTypeKind.DateTimeOffset.getFullQualifiedName()) + .setMapping(mapping); + EdmParameter edmParameter = new EdmParameterImpl(null, parameter); + + assertNotNull(edmParameter.getMapping()); + assertEquals(Date.class, edmParameter.getMapping().getMappedJavaClass()); + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMemberImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMemberImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMemberImplTest.java new file mode 100644 index 0000000..a5e774c --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmMemberImplTest.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.mock; + +import org.apache.olingo.commons.api.edm.provider.CsdlEnumMember; +import org.apache.olingo.commons.core.edm.EdmMemberImpl; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Test; + +public class EdmMemberImplTest { + + @Test + public void enumMember() { + final CsdlEnumMember member = new CsdlEnumMember().setName("name").setValue("value"); + final EdmMemberImpl memberImpl = new EdmMemberImpl(mock(EdmProviderImpl.class), null, member); + + assertEquals("name", memberImpl.getName()); + assertEquals("value", memberImpl.getValue()); + } + +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmNavigationPropertyImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmNavigationPropertyImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmNavigationPropertyImplTest.java new file mode 100644 index 0000000..bfab176 --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmNavigationPropertyImplTest.java @@ -0,0 +1,146 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmNavigationProperty; +import org.apache.olingo.commons.api.edm.EdmType; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.constants.EdmTypeKind; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityType; +import org.apache.olingo.commons.api.edm.provider.CsdlNavigationProperty; +import org.apache.olingo.commons.api.edm.provider.CsdlPropertyRef; +import org.apache.olingo.commons.api.edm.provider.CsdlReferentialConstraint; +import org.apache.olingo.commons.core.edm.EdmNavigationPropertyImpl; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Test; + +public class EdmNavigationPropertyImplTest { + + @Test + public void navigationProperty() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName entityTypeName = new FullQualifiedName("ns", "entity"); + CsdlEntityType entityTypeProvider = new CsdlEntityType(); + entityTypeProvider.setKey(Collections.<CsdlPropertyRef> emptyList()); + when(provider.getEntityType(entityTypeName)).thenReturn(entityTypeProvider); + CsdlNavigationProperty propertyProvider = new CsdlNavigationProperty(); + propertyProvider.setType(entityTypeName); + propertyProvider.setNullable(false); + EdmNavigationProperty property = new EdmNavigationPropertyImpl(edm, entityTypeName, propertyProvider); + assertFalse(property.isCollection()); + assertFalse(property.isNullable()); + EdmType type = property.getType(); + assertEquals(EdmTypeKind.ENTITY, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("entity", type.getName()); + assertNull(property.getReferencingPropertyName("referencedPropertyName")); + assertNull(property.getPartner()); + + // Test caching + EdmType cachedType = property.getType(); + assertTrue(type == cachedType); + } + + @Test + public void navigationPropertyWithReferntialConstraint() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName entityTypeName = new FullQualifiedName("ns", "entity"); + CsdlEntityType entityTypeProvider = new CsdlEntityType(); + entityTypeProvider.setKey(Collections.<CsdlPropertyRef> emptyList()); + when(provider.getEntityType(entityTypeName)).thenReturn(entityTypeProvider); + CsdlNavigationProperty propertyProvider = new CsdlNavigationProperty(); + propertyProvider.setType(entityTypeName); + propertyProvider.setNullable(false); + List<CsdlReferentialConstraint> referentialConstraints = new ArrayList<CsdlReferentialConstraint>(); + referentialConstraints.add(new CsdlReferentialConstraint().setProperty("property").setReferencedProperty( + "referencedProperty")); + propertyProvider.setReferentialConstraints(referentialConstraints); + EdmNavigationProperty property = new EdmNavigationPropertyImpl(edm, entityTypeName, propertyProvider); + assertEquals("property", property.getReferencingPropertyName("referencedProperty")); + assertNull(property.getReferencingPropertyName("wrong")); + } + + @Test + public void navigationPropertyWithPartner() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName entityTypeName = new FullQualifiedName("ns", "entity"); + CsdlEntityType entityTypeProvider = new CsdlEntityType(); + entityTypeProvider.setKey(Collections.<CsdlPropertyRef> emptyList()); + + List<CsdlNavigationProperty> navigationProperties = new ArrayList<CsdlNavigationProperty>(); + navigationProperties.add(new CsdlNavigationProperty().setName("partnerName").setType(entityTypeName)); + entityTypeProvider.setNavigationProperties(navigationProperties); + when(provider.getEntityType(entityTypeName)).thenReturn(entityTypeProvider); + CsdlNavigationProperty propertyProvider = new CsdlNavigationProperty(); + propertyProvider.setType(entityTypeName); + propertyProvider.setNullable(false); + propertyProvider.setPartner("partnerName"); + EdmNavigationProperty property = new EdmNavigationPropertyImpl(edm, entityTypeName, propertyProvider); + EdmNavigationProperty partner = property.getPartner(); + assertNotNull(partner); + + // Caching + assertTrue(partner == property.getPartner()); + } + + @Test(expected = EdmException.class) + public void navigationPropertyWithNonexistentPartner() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName entityTypeName = new FullQualifiedName("ns", "entity"); + CsdlEntityType entityTypeProvider = new CsdlEntityType(); + entityTypeProvider.setKey(Collections.<CsdlPropertyRef> emptyList()); + + List<CsdlNavigationProperty> navigationProperties = new ArrayList<CsdlNavigationProperty>(); + navigationProperties.add(new CsdlNavigationProperty().setName("partnerName").setType(entityTypeName)); + entityTypeProvider.setNavigationProperties(navigationProperties); + when(provider.getEntityType(entityTypeName)).thenReturn(entityTypeProvider); + CsdlNavigationProperty propertyProvider = new CsdlNavigationProperty(); + propertyProvider.setType(entityTypeName); + propertyProvider.setNullable(false); + propertyProvider.setPartner("wrong"); + EdmNavigationProperty property = new EdmNavigationPropertyImpl(edm, entityTypeName, propertyProvider); + property.getPartner(); + } + + @Test(expected = EdmException.class) + public void navigationPropertyWithNonExistentType() throws Exception { + EdmProviderImpl edm = mock(EdmProviderImpl.class); + CsdlNavigationProperty propertyProvider = new CsdlNavigationProperty(); + EdmNavigationProperty property = new EdmNavigationPropertyImpl(edm, null, propertyProvider); + property.getType(); + } +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmParameterImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmParameterImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmParameterImplTest.java new file mode 100644 index 0000000..5babbdb --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmParameterImplTest.java @@ -0,0 +1,143 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmParameter; +import org.apache.olingo.commons.api.edm.EdmPrimitiveType; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.EdmType; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.constants.EdmTypeKind; +import org.apache.olingo.commons.api.edm.provider.CsdlComplexType; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEnumType; +import org.apache.olingo.commons.api.edm.provider.CsdlParameter; +import org.apache.olingo.commons.api.edm.provider.CsdlTypeDefinition; +import org.apache.olingo.commons.core.edm.EdmParameterImpl; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Test; + +public class EdmParameterImplTest { + + @Test + public void getTypeReturnsPrimitiveType() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(EdmPrimitiveTypeKind.Binary.getFullQualifiedName()); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + final EdmType type = parameter.getType(); + assertEquals(EdmTypeKind.PRIMITIVE, type.getKind()); + assertEquals(EdmPrimitiveType.EDM_NAMESPACE, type.getNamespace()); + assertEquals(EdmPrimitiveTypeKind.Binary.toString(), type.getName()); + } + + @Test + public void getTypeReturnsComplexType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName complexTypeName = new FullQualifiedName("ns", "complex"); + CsdlComplexType complexTypeProvider = new CsdlComplexType(); + when(provider.getComplexType(complexTypeName)).thenReturn(complexTypeProvider); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(complexTypeName); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + assertFalse(parameter.isCollection()); + final EdmType type = parameter.getType(); + assertEquals(EdmTypeKind.COMPLEX, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("complex", type.getName()); + } + + @Test + public void getTypeReturnsEnumType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName enumTypeName = new FullQualifiedName("ns", "enum"); + CsdlEnumType enumTypeProvider = new CsdlEnumType(); + when(provider.getEnumType(enumTypeName)).thenReturn(enumTypeProvider); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(enumTypeName); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + assertFalse(parameter.isCollection()); + final EdmType type = parameter.getType(); + assertEquals(EdmTypeKind.ENUM, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("enum", type.getName()); + } + + @Test + public void getTypeReturnsTypeDefinition() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName typeName = new FullQualifiedName("ns", "definition"); + CsdlTypeDefinition typeProvider = + new CsdlTypeDefinition().setUnderlyingType(new FullQualifiedName("Edm", "String")); + when(provider.getTypeDefinition(typeName)).thenReturn(typeProvider); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(typeName); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + final EdmType type = parameter.getType(); + assertEquals(EdmTypeKind.DEFINITION, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("definition", type.getName()); + } + + @Test + public void facets() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(EdmPrimitiveTypeKind.String.getFullQualifiedName()); + parameterProvider.setPrecision(42); + parameterProvider.setScale(12); + parameterProvider.setMaxLength(128); + parameterProvider.setNullable(false); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + assertNull(parameter.getMapping()); + assertEquals(Integer.valueOf(42), parameter.getPrecision()); + assertEquals(Integer.valueOf(12), parameter.getScale()); + assertEquals(Integer.valueOf(128), parameter.getMaxLength()); + assertFalse(parameter.isNullable()); + } + + @Test(expected = EdmException.class) + public void getTypeWithInvalidSimpleType() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(new FullQualifiedName("Edm", "wrong")); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + parameter.getType(); + } + + @Test(expected = EdmException.class) + public void getTypeWithNonexistingType() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlParameter parameterProvider = new CsdlParameter(); + parameterProvider.setType(new FullQualifiedName("wrong", "wrong")); + final EdmParameter parameter = new EdmParameterImpl(edm, parameterProvider); + parameter.getType(); + } + +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmPropertyImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmPropertyImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmPropertyImplTest.java new file mode 100644 index 0000000..e9f907f --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmPropertyImplTest.java @@ -0,0 +1,158 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmPrimitiveType; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.EdmProperty; +import org.apache.olingo.commons.api.edm.EdmType; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.constants.EdmTypeKind; +import org.apache.olingo.commons.api.edm.provider.CsdlComplexType; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEnumType; +import org.apache.olingo.commons.api.edm.provider.CsdlProperty; +import org.apache.olingo.commons.api.edm.provider.CsdlTypeDefinition; +import org.apache.olingo.commons.core.edm.EdmPropertyImpl; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Test; + +public class EdmPropertyImplTest { + + @Test + public void getTypeReturnsPrimitiveType() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlProperty propertyProvider = new CsdlProperty(); + propertyProvider.setType(EdmPrimitiveTypeKind.Binary.getFullQualifiedName()); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + assertTrue(property.isPrimitive()); + final EdmType type = property.getType(); + assertEquals(EdmTypeKind.PRIMITIVE, type.getKind()); + assertEquals(EdmPrimitiveType.EDM_NAMESPACE, type.getNamespace()); + assertEquals(EdmPrimitiveTypeKind.Binary.toString(), type.getName()); + } + + @Test + public void getTypeReturnsComplexType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName complexTypeName = new FullQualifiedName("ns", "complex"); + CsdlComplexType complexTypeProvider = new CsdlComplexType(); + when(provider.getComplexType(complexTypeName)).thenReturn(complexTypeProvider); + CsdlProperty propertyProvider = new CsdlProperty(); + propertyProvider.setType(complexTypeName); + final EdmProperty property = new EdmPropertyImpl(edm, complexTypeName, propertyProvider); + assertFalse(property.isCollection()); + assertFalse(property.isPrimitive()); + final EdmType type = property.getType(); + assertEquals(EdmTypeKind.COMPLEX, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("complex", type.getName()); + } + + @Test + public void getTypeReturnsEnumType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName enumTypeName = new FullQualifiedName("ns", "enum"); + CsdlEnumType enumTypeProvider = new CsdlEnumType(); + when(provider.getEnumType(enumTypeName)).thenReturn(enumTypeProvider); + CsdlProperty propertyProvider = new CsdlProperty(); + propertyProvider.setType(enumTypeName); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + assertFalse(property.isCollection()); + assertFalse(property.isPrimitive()); + final EdmType type = property.getType(); + assertEquals(EdmTypeKind.ENUM, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("enum", type.getName()); + } + + @Test + public void getTypeReturnsTypeDefinition() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final FullQualifiedName typeName = new FullQualifiedName("ns", "definition"); + CsdlTypeDefinition typeProvider = + new CsdlTypeDefinition().setUnderlyingType(new FullQualifiedName("Edm", "String")); + when(provider.getTypeDefinition(typeName)).thenReturn(typeProvider); + CsdlProperty propertyProvider = new CsdlProperty(); + propertyProvider.setType(typeName); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + assertFalse(property.isPrimitive()); + final EdmType type = property.getType(); + assertEquals(EdmTypeKind.DEFINITION, type.getKind()); + assertEquals("ns", type.getNamespace()); + assertEquals("definition", type.getName()); + } + + @Test(expected = EdmException.class) + public void getTypeReturnsWrongType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final CsdlProperty propertyProvider = new CsdlProperty() + .setType(new FullQualifiedName("ns", "wrong")); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + property.getType(); + fail(); + } + + @Test(expected = EdmException.class) + public void getTypeReturnsNoTypeKind() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + final CsdlProperty propertyProvider = new CsdlProperty() + .setType(new FullQualifiedName(EdmPrimitiveType.EDM_NAMESPACE, "type")); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + property.getType(); + fail(); + } + + @Test + public void facets() { + EdmProviderImpl edm = new EdmProviderImpl(mock(CsdlEdmProvider.class)); + CsdlProperty propertyProvider = new CsdlProperty(); + propertyProvider.setType(EdmPrimitiveTypeKind.String.getFullQualifiedName()); + propertyProvider.setPrecision(42); + propertyProvider.setScale(12); + propertyProvider.setMaxLength(128); + propertyProvider.setUnicode(true); + propertyProvider.setNullable(false); + propertyProvider.setDefaultValue("x"); + final EdmProperty property = new EdmPropertyImpl(edm, null, propertyProvider); + assertTrue(property.isPrimitive()); + assertNull(property.getMapping()); + assertNull(property.getMimeType()); + assertEquals(Integer.valueOf(42), property.getPrecision()); + assertEquals(Integer.valueOf(12), property.getScale()); + assertEquals(Integer.valueOf(128), property.getMaxLength()); + assertTrue(property.isUnicode()); + assertFalse(property.isNullable()); + assertEquals("x", property.getDefaultValue()); + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplOverloadingTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplOverloadingTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplOverloadingTest.java new file mode 100644 index 0000000..45d3d2b --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplOverloadingTest.java @@ -0,0 +1,199 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNotSame; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmAction; +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmFunction; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlAction; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlFunction; +import org.apache.olingo.commons.api.edm.provider.CsdlParameter; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Before; +import org.junit.Test; + +public class EdmProviderImplOverloadingTest { + + private Edm edm; + private final FullQualifiedName operationName1 = new FullQualifiedName("n", "o1"); + private final FullQualifiedName operationType1 = new FullQualifiedName("n", "t1"); + private final FullQualifiedName operationType2 = new FullQualifiedName("n", "t2"); + private final FullQualifiedName wrongOperationName = new FullQualifiedName("wrong", "wrong"); + private final FullQualifiedName badOperationName = new FullQualifiedName("bad", "bad"); + + @Before + public void setup() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + + List<CsdlAction> actions = new ArrayList<CsdlAction>(); + CsdlAction action = new CsdlAction().setName(operationName1.getName()); + actions.add(action); + List<CsdlParameter> action1Parameters = new ArrayList<CsdlParameter>(); + action1Parameters.add(new CsdlParameter().setType(operationType1).setCollection(false)); + action = + new CsdlAction().setName(operationName1.getName()).setBound(true).setParameters(action1Parameters); + actions.add(action); + List<CsdlParameter> action2Parameters = new ArrayList<CsdlParameter>(); + action2Parameters.add(new CsdlParameter().setType(operationType1).setCollection(true)); + action = + new CsdlAction().setName(operationName1.getName()).setBound(true).setParameters(action2Parameters); + actions.add(action); + when(provider.getActions(operationName1)).thenReturn(actions); + + List<CsdlFunction> functions = new ArrayList<CsdlFunction>(); + CsdlFunction function = new CsdlFunction().setName(operationName1.getName()); + functions.add(function); + List<CsdlParameter> function1Parameters = new ArrayList<CsdlParameter>(); + function1Parameters.add(new CsdlParameter().setType(operationType1).setName("a")); + function = new CsdlFunction().setName(operationName1.getName()).setParameters(function1Parameters); + functions.add(function); + List<CsdlParameter> function2Parameters = new ArrayList<CsdlParameter>(); + function2Parameters.add(new CsdlParameter().setType(operationType1).setName("b")); + function = new CsdlFunction().setName(operationName1.getName()).setParameters(function2Parameters); + functions.add(function); + List<CsdlParameter> function3Parameters = new ArrayList<CsdlParameter>(); + function3Parameters.add(new CsdlParameter().setName("a").setType(operationType1)); + function3Parameters.add(new CsdlParameter().setName("b").setType(operationType1)); + function = new CsdlFunction().setName(operationName1.getName()).setParameters(function3Parameters).setBound(true); + functions.add(function); + List<CsdlParameter> function4Parameters = new ArrayList<CsdlParameter>(); + function4Parameters.add(new CsdlParameter().setName("a").setType(operationType2)); + function4Parameters.add(new CsdlParameter().setName("b").setType(operationType2)); + function = new CsdlFunction().setName(operationName1.getName()).setParameters(function4Parameters).setBound(true); + functions.add(function); + when(provider.getFunctions(operationName1)).thenReturn(functions); + + List<CsdlFunction> badFunctions = new ArrayList<CsdlFunction>(); + CsdlFunction badFunction = new CsdlFunction().setName(operationName1.getName()).setBound(true).setParameters(null); + badFunctions.add(badFunction); + + when(provider.getFunctions(badOperationName)).thenReturn(badFunctions); + + edm = new EdmProviderImpl(provider); + } + + @Test + public void simpleActionGet() { + EdmAction action = edm.getUnboundAction(operationName1); + assertNotNull(action); + assertEquals(operationName1.getNamespace(), action.getNamespace()); + assertEquals(operationName1.getName(), action.getName()); + + assertNull(edm.getUnboundAction(wrongOperationName)); + } + + @Test + public void boundActionOverloading() { + EdmAction action = edm.getBoundAction(operationName1, operationType1, false); + assertNotNull(action); + assertEquals(operationName1.getNamespace(), action.getNamespace()); + assertEquals(operationName1.getName(), action.getName()); + assertTrue(action == edm.getBoundAction(operationName1, operationType1, false)); + + EdmAction action2 = edm.getBoundAction(operationName1, operationType1, true); + assertNotNull(action2); + assertEquals(operationName1.getNamespace(), action2.getNamespace()); + assertEquals(operationName1.getName(), action2.getName()); + assertTrue(action2 == edm.getBoundAction(operationName1, operationType1, true)); + + assertNotSame(action, action2); + } + + @Test + public void simpleFunctionGet() { + EdmFunction function = edm.getUnboundFunction(operationName1, null); + assertNotNull(function); + assertEquals(operationName1.getNamespace(), function.getNamespace()); + assertEquals(operationName1.getName(), function.getName()); + + EdmFunction function2 = edm.getUnboundFunction(operationName1, new ArrayList<String>()); + assertNotNull(function2); + assertEquals(operationName1.getNamespace(), function2.getNamespace()); + assertEquals(operationName1.getName(), function2.getName()); + + assertEquals(function, function2); + + assertNull(edm.getUnboundFunction(wrongOperationName, new ArrayList<String>())); + } + + @Test + public void functionOverloading() { + ArrayList<String> parameter1Names = new ArrayList<String>(); + parameter1Names.add("a"); + List<String> parameter2Names = new ArrayList<String>(); + parameter2Names.add("b"); + EdmFunction function = edm.getUnboundFunction(operationName1, new ArrayList<String>()); + assertNotNull(function); + assertFalse(function.isBound()); + + EdmFunction function1 = edm.getUnboundFunction(operationName1, parameter1Names); + assertNotNull(function1); + assertFalse(function1.isBound()); + + assertFalse(function == function1); + assertNotSame(function, function1); + + EdmFunction function2 = edm.getUnboundFunction(operationName1, parameter2Names); + assertNotNull(function2); + assertFalse(function2.isBound()); + + assertFalse(function1 == function2); + assertNotSame(function1, function2); + + EdmFunction function3 = edm.getBoundFunction(operationName1, operationType1, false, parameter2Names); + assertNotNull(function3); + assertTrue(function3.isBound()); + EdmFunction function4 = edm.getBoundFunction(operationName1, operationType2, false, parameter2Names); + assertNotNull(function4); + assertTrue(function4.isBound()); + + assertFalse(function3 == function4); + assertNotSame(function3, function4); + + assertFalse(function1 == function3); + assertFalse(function1 == function4); + assertFalse(function2 == function3); + assertFalse(function2 == function4); + assertNotSame(function1, function3); + assertNotSame(function1, function4); + assertNotSame(function2, function3); + assertNotSame(function2, function4); + } + + @Test(expected = EdmException.class) + public void noParametersAtBoundFunctionReslutsInException() { + edm.getBoundFunction(badOperationName, operationType1, true, null); + } + +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplTest.java new file mode 100644 index 0000000..c094b1d --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmProviderImplTest.java @@ -0,0 +1,225 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.fail; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; + +import org.apache.olingo.commons.api.ex.ODataException; +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmComplexType; +import org.apache.olingo.commons.api.edm.EdmEntityContainer; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmEnumType; +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmTypeDefinition; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlAliasInfo; +import org.apache.olingo.commons.api.edm.provider.CsdlComplexType; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainerInfo; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityType; +import org.apache.olingo.commons.api.edm.provider.CsdlEnumType; +import org.apache.olingo.commons.api.edm.provider.CsdlPropertyRef; +import org.apache.olingo.commons.api.edm.provider.CsdlTypeDefinition; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Before; +import org.junit.Test; + +public class EdmProviderImplTest { + + private Edm edm; + private final FullQualifiedName FQN = new FullQualifiedName("testNamespace", "testName"); + private final FullQualifiedName WRONG_FQN = new FullQualifiedName("wrong", "wrong"); + + @Before + public void setup() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + CsdlEntityContainerInfo containerInfo = new CsdlEntityContainerInfo().setContainerName(FQN); + when(provider.getEntityContainerInfo(FQN)).thenReturn(containerInfo); + when(provider.getEntityContainerInfo(null)).thenReturn(containerInfo); + + CsdlEnumType enumType = new CsdlEnumType().setName(FQN.getName()); + when(provider.getEnumType(FQN)).thenReturn(enumType); + + CsdlTypeDefinition typeDefinition = + new CsdlTypeDefinition().setName(FQN.getName()).setUnderlyingType(new FullQualifiedName("Edm", "String")); + when(provider.getTypeDefinition(FQN)).thenReturn(typeDefinition); + + CsdlEntityType entityType = new CsdlEntityType().setName(FQN.getName()).setKey(new ArrayList<CsdlPropertyRef>()); + when(provider.getEntityType(FQN)).thenReturn(entityType); + + CsdlComplexType complexType = new CsdlComplexType().setName(FQN.getName()); + when(provider.getComplexType(FQN)).thenReturn(complexType); + + List<CsdlAliasInfo> aliasInfos = new ArrayList<CsdlAliasInfo>(); + aliasInfos.add(new CsdlAliasInfo().setAlias("alias").setNamespace("namespace")); + when(provider.getAliasInfos()).thenReturn(aliasInfos); + + edm = new EdmProviderImpl(provider); + } + + @Test + public void nothingSpecifiedMustNotResultInExceptions() throws Exception { + CsdlEdmProvider localProvider = mock(CsdlEdmProvider.class); + when(localProvider.getActions(FQN)).thenReturn(null); + when(localProvider.getFunctions(FQN)).thenReturn(null); + Edm localEdm = new EdmProviderImpl(localProvider); + localEdm.getUnboundAction(FQN); + localEdm.getUnboundFunction(FQN, null); + localEdm.getBoundAction(FQN, FQN, true); + localEdm.getBoundFunction(FQN, FQN, true, null); + localEdm.getComplexType(FQN); + localEdm.getEntityContainer(FQN); + localEdm.getEntityType(FQN); + localEdm.getEnumType(FQN); + localEdm.getTypeDefinition(FQN); + } + + @Test + public void convertExceptionsTest() throws Exception { + CsdlEdmProvider localProvider = mock(CsdlEdmProvider.class); + FullQualifiedName fqn = new FullQualifiedName("namespace", "name"); + when(localProvider.getEntityContainerInfo(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getEnumType(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getTypeDefinition(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getEntityType(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getComplexType(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getActions(fqn)).thenThrow(new ODataException("msg")); + when(localProvider.getFunctions(fqn)).thenThrow(new ODataException("msg")); + + Edm localEdm = new EdmProviderImpl(localProvider); + + callMethodAndExpectEdmException(localEdm, "getEntityContainer"); + callMethodAndExpectEdmException(localEdm, "getEnumType"); + callMethodAndExpectEdmException(localEdm, "getTypeDefinition"); + callMethodAndExpectEdmException(localEdm, "getEntityType"); + callMethodAndExpectEdmException(localEdm, "getComplexType"); + + // seperate because of signature + try { + localEdm.getUnboundAction(fqn); + } catch (EdmException e) { + assertEquals("org.apache.olingo.commons.api.ex.ODataException: msg", e.getMessage()); + } + + try { + localEdm.getUnboundFunction(fqn, null); + } catch (EdmException e) { + assertEquals("org.apache.olingo.commons.api.ex.ODataException: msg", e.getMessage()); + } + try { + localEdm.getBoundAction(fqn, fqn, true); + } catch (EdmException e) { + assertEquals("org.apache.olingo.commons.api.ex.ODataException: msg", e.getMessage()); + } + + try { + localEdm.getBoundFunction(fqn, fqn, true, null); + } catch (EdmException e) { + assertEquals("org.apache.olingo.commons.api.ex.ODataException: msg", e.getMessage()); + } + } + + private void callMethodAndExpectEdmException(final Edm localEdm, final String methodName) throws Exception { + Method method = localEdm.getClass().getMethod(methodName, FullQualifiedName.class); + try { + method.invoke(localEdm, new FullQualifiedName("namespace", "name")); + } catch (InvocationTargetException e) { + Throwable cause = e.getCause(); + if (cause instanceof EdmException) { + return; + } + } + fail("EdmException expected for method: " + methodName); + } + + @Test(expected = EdmException.class) + public void convertExceptionsAliasTest() throws Exception { + CsdlEdmProvider localProvider = mock(CsdlEdmProvider.class); + when(localProvider.getAliasInfos()).thenThrow(new ODataException("msg")); + + Edm localEdm = new EdmProviderImpl(localProvider); + localEdm.getEntityContainer(null); + } + + @Test + public void getEntityContainer() { + EdmEntityContainer entityContainer = edm.getEntityContainer(FQN); + assertNotNull(entityContainer); + assertEquals(FQN.getNamespace(), entityContainer.getNamespace()); + assertEquals(FQN.getName(), entityContainer.getName()); + + entityContainer = edm.getEntityContainer(null); + assertNotNull(entityContainer); + assertEquals(FQN.getNamespace(), entityContainer.getNamespace()); + assertEquals(FQN.getName(), entityContainer.getName()); + + assertNull(edm.getEntityContainer(WRONG_FQN)); + } + + @Test + public void getEnumType() { + EdmEnumType enumType = edm.getEnumType(FQN); + assertNotNull(enumType); + assertEquals(FQN.getNamespace(), enumType.getNamespace()); + assertEquals(FQN.getName(), enumType.getName()); + + assertNull(edm.getEnumType(WRONG_FQN)); + } + + @Test + public void getTypeDefinition() { + EdmTypeDefinition typeDefinition = edm.getTypeDefinition(FQN); + assertNotNull(typeDefinition); + assertEquals(FQN.getNamespace(), typeDefinition.getNamespace()); + assertEquals(FQN.getName(), typeDefinition.getName()); + + assertNull(edm.getTypeDefinition(WRONG_FQN)); + } + + @Test + public void getEntityType() { + EdmEntityType entityType = edm.getEntityType(FQN); + assertNotNull(entityType); + assertEquals(FQN.getNamespace(), entityType.getNamespace()); + assertEquals(FQN.getName(), entityType.getName()); + + assertNull(edm.getEntityType(WRONG_FQN)); + } + + @Test + public void getComplexType() { + EdmComplexType complexType = edm.getComplexType(FQN); + assertNotNull(complexType); + assertEquals(FQN.getNamespace(), complexType.getNamespace()); + assertEquals(FQN.getName(), complexType.getName()); + + assertNull(edm.getComplexType(WRONG_FQN)); + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmReturnTypeImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmReturnTypeImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmReturnTypeImplTest.java new file mode 100644 index 0000000..ac36635 --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmReturnTypeImplTest.java @@ -0,0 +1,134 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.olingo.commons.api.edm.EdmComplexType; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmEnumType; +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.EdmReturnType; +import org.apache.olingo.commons.api.edm.EdmType; +import org.apache.olingo.commons.api.edm.EdmTypeDefinition; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlReturnType; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.apache.olingo.commons.core.edm.EdmReturnTypeImpl; +import org.apache.olingo.commons.core.edm.primitivetype.EdmPrimitiveTypeFactory; +import org.junit.Test; + +public class EdmReturnTypeImplTest { + + @Test + public void primitiveReturnType() { + CsdlReturnType providerType = new CsdlReturnType().setType(new FullQualifiedName("Edm", "String")); + + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock(EdmProviderImpl.class), providerType); + + assertEquals(EdmPrimitiveTypeFactory.getInstance(EdmPrimitiveTypeKind.String), typeImpl.getType()); + assertFalse(typeImpl.isCollection()); + assertTrue(typeImpl.isNullable()); + + assertNull(typeImpl.getPrecision()); + assertNull(typeImpl.getMaxLength()); + assertNull(typeImpl.getScale()); + } + + @Test + public void primitiveCollectionReturnType() { + CsdlReturnType providerType = new CsdlReturnType().setType( + new FullQualifiedName("Edm", "String")).setCollection(true); + + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock(EdmProviderImpl.class), providerType); + + assertEquals(EdmPrimitiveTypeFactory.getInstance(EdmPrimitiveTypeKind.String), typeImpl.getType()); + assertTrue(typeImpl.isCollection()); + } + + @Test(expected = EdmException.class) + public void invalidPrimitiveType() { + CsdlReturnType providerType = new CsdlReturnType().setType( + new FullQualifiedName("Edm", "wrong")).setCollection(true); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock(EdmProviderImpl.class), providerType); + typeImpl.getType(); + } + + @Test + public void complexType() { + EdmProviderImpl mock = mock(EdmProviderImpl.class); + FullQualifiedName baseType = new FullQualifiedName("namespace", "type"); + EdmComplexType edmType = mock(EdmComplexType.class); + when(mock.getComplexType(baseType)).thenReturn(edmType); + CsdlReturnType providerType = new CsdlReturnType().setType(baseType); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock, providerType); + EdmType returnedType = typeImpl.getType(); + assertEquals(edmType, returnedType); + } + + @Test + public void entityType() { + EdmProviderImpl mock = mock(EdmProviderImpl.class); + FullQualifiedName baseType = new FullQualifiedName("namespace", "type"); + EdmEntityType edmType = mock(EdmEntityType.class); + when(mock.getEntityType(baseType)).thenReturn(edmType); + CsdlReturnType providerType = new CsdlReturnType().setType(baseType); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock, providerType); + EdmType returnedType = typeImpl.getType(); + assertEquals(edmType, returnedType); + } + + @Test + public void enumType() { + EdmProviderImpl mock = mock(EdmProviderImpl.class); + FullQualifiedName baseType = new FullQualifiedName("namespace", "type"); + EdmEnumType edmType = mock(EdmEnumType.class); + when(mock.getEnumType(baseType)).thenReturn(edmType); + CsdlReturnType providerType = new CsdlReturnType().setType(baseType); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock, providerType); + EdmType returnedType = typeImpl.getType(); + assertEquals(edmType, returnedType); + } + + @Test + public void typeDefinition() { + EdmProviderImpl mock = mock(EdmProviderImpl.class); + FullQualifiedName baseType = new FullQualifiedName("namespace", "type"); + EdmTypeDefinition edmType = mock(EdmTypeDefinition.class); + when(mock.getTypeDefinition(baseType)).thenReturn(edmType); + CsdlReturnType providerType = new CsdlReturnType().setType(baseType); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock, providerType); + EdmType returnedType = typeImpl.getType(); + assertEquals(edmType, returnedType); + } + + @Test(expected = EdmException.class) + public void invalidType() { + CsdlReturnType providerType = new CsdlReturnType().setType(new FullQualifiedName("wrong", "wrong")); + EdmReturnType typeImpl = new EdmReturnTypeImpl(mock(EdmProviderImpl.class), providerType); + typeImpl.getType(); + } + +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSchemaImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSchemaImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSchemaImplTest.java new file mode 100644 index 0000000..fd344c5 --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSchemaImplTest.java @@ -0,0 +1,363 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.olingo.commons.api.ex.ODataException; +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmAction; +import org.apache.olingo.commons.api.edm.EdmActionImport; +import org.apache.olingo.commons.api.edm.EdmComplexType; +import org.apache.olingo.commons.api.edm.EdmEntityContainer; +import org.apache.olingo.commons.api.edm.EdmEntitySet; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmEnumType; +import org.apache.olingo.commons.api.edm.EdmFunction; +import org.apache.olingo.commons.api.edm.EdmFunctionImport; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.EdmSchema; +import org.apache.olingo.commons.api.edm.EdmSingleton; +import org.apache.olingo.commons.api.edm.EdmTypeDefinition; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlAbstractEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlAction; +import org.apache.olingo.commons.api.edm.provider.CsdlActionImport; +import org.apache.olingo.commons.api.edm.provider.CsdlAliasInfo; +import org.apache.olingo.commons.api.edm.provider.CsdlComplexType; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainer; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainerInfo; +import org.apache.olingo.commons.api.edm.provider.CsdlEntitySet; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityType; +import org.apache.olingo.commons.api.edm.provider.CsdlEnumType; +import org.apache.olingo.commons.api.edm.provider.CsdlFunction; +import org.apache.olingo.commons.api.edm.provider.CsdlFunctionImport; +import org.apache.olingo.commons.api.edm.provider.CsdlSchema; +import org.apache.olingo.commons.api.edm.provider.CsdlSingleton; +import org.apache.olingo.commons.api.edm.provider.CsdlTerm; +import org.apache.olingo.commons.api.edm.provider.CsdlTypeDefinition; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.junit.Before; +import org.junit.Test; + +public class EdmSchemaImplTest { + + private EdmSchema schema; + private Edm edm; + + @Before + public void before() { + CsdlEdmProvider provider = new LocalProvider(); + edm = new EdmProviderImpl(provider); + schema = edm.getSchemas().get(0); + + } + + @Test + public void initialSchemaTest() { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + edm = new EdmProviderImpl(provider); + edm.getSchemas(); + } + + @Test + public void emptySchemaTest() throws Exception { + ArrayList<CsdlSchema> schemas = new ArrayList<CsdlSchema>(); + CsdlSchema providerSchema = new CsdlSchema(); + schemas.add(providerSchema); + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + when(provider.getSchemas()).thenReturn(schemas); + edm = new EdmProviderImpl(provider); + edm.getSchemas(); + } + + @Test + public void basicGetters() { + assertEquals("org.namespace", schema.getNamespace()); + assertEquals("alias", schema.getAlias()); + } + + @Test + public void getTypeDefinitions() { + List<EdmTypeDefinition> typeDefinitions = schema.getTypeDefinitions(); + assertNotNull(typeDefinitions); + assertEquals(2, typeDefinitions.size()); + + for (EdmTypeDefinition def : typeDefinitions) { + assertTrue(def == edm.getTypeDefinition(new FullQualifiedName("org.namespace", def.getName()))); + } + } + + @Test + public void getEnumTypes() { + List<EdmEnumType> enumTypes = schema.getEnumTypes(); + assertNotNull(enumTypes); + assertEquals(2, enumTypes.size()); + + for (EdmEnumType enumType : enumTypes) { + assertTrue(enumType == edm.getEnumType(new FullQualifiedName("org.namespace", enumType.getName()))); + } + } + + @Test + public void getEntityTypes() { + List<EdmEntityType> entityTypes = schema.getEntityTypes(); + assertNotNull(entityTypes); + assertEquals(2, entityTypes.size()); + + for (EdmEntityType entityType : entityTypes) { + assertTrue(entityType == edm.getEntityType(new FullQualifiedName("org.namespace", entityType.getName()))); + } + } + + @Test + public void getComplexTypes() { + List<EdmComplexType> complexTypes = schema.getComplexTypes(); + assertNotNull(complexTypes); + assertEquals(2, complexTypes.size()); + + for (EdmComplexType complexType : complexTypes) { + assertTrue(complexType == edm.getComplexType(new FullQualifiedName("org.namespace", complexType.getName()))); + } + } + + @Test + public void getActions() { + List<EdmAction> actions = schema.getActions(); + assertNotNull(actions); + assertEquals(2, actions.size()); + + for (EdmAction action : actions) { + assertTrue(action == edm.getUnboundAction(new FullQualifiedName("org.namespace", action.getName()))); + } + } + + @Test + public void getFunctions() { + List<EdmFunction> functions = schema.getFunctions(); + assertNotNull(functions); + assertEquals(2, functions.size()); + + for (EdmFunction function : functions) { + FullQualifiedName functionName = new FullQualifiedName("org.namespace", function.getName()); + assertTrue(function == edm.getUnboundFunction(functionName, null)); + } + } + + @Test + public void getContainer() { + EdmEntityContainer container = schema.getEntityContainer(); + assertNotNull(container); + + List<EdmEntitySet> entitySets = container.getEntitySets(); + assertNotNull(entitySets); + assertEquals(2, entitySets.size()); + for (EdmEntitySet obj : entitySets) { + assertNotNull(obj.getEntityType()); + } + + List<EdmSingleton> singletons = container.getSingletons(); + assertNotNull(singletons); + assertEquals(2, singletons.size()); + for (EdmSingleton obj : singletons) { + assertNotNull(obj.getEntityType()); + } + + List<EdmActionImport> actionImports = container.getActionImports(); + assertNotNull(actionImports); + assertEquals(2, actionImports.size()); + for (EdmActionImport obj : actionImports) { + assertNotNull(obj.getUnboundAction()); + } + + List<EdmFunctionImport> functionImports = container.getFunctionImports(); + assertNotNull(functionImports); + assertEquals(2, functionImports.size()); + for (EdmFunctionImport obj : functionImports) { + assertNotNull(obj.getFunctionFqn()); + } + + assertTrue(container == edm.getEntityContainer(new FullQualifiedName(schema.getNamespace(), container.getName()))); + assertTrue(container == edm.getEntityContainer(null)); + } + + private class LocalProvider extends CsdlAbstractEdmProvider { + + private static final String ALIAS = "alias"; + private static final String NAMESPACE = "org.namespace"; + + @Override + public CsdlEnumType getEnumType(final FullQualifiedName enumTypeName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlTypeDefinition getTypeDefinition(final FullQualifiedName typeDefinitionName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlEntityType getEntityType(final FullQualifiedName entityTypeName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlComplexType getComplexType(final FullQualifiedName complexTypeName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public List<CsdlAction> getActions(final FullQualifiedName actionName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public List<CsdlFunction> getFunctions(final FullQualifiedName functionName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlTerm getTerm(final FullQualifiedName termName) throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlEntitySet getEntitySet(final FullQualifiedName entityContainer, final String entitySetName) + throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlSingleton getSingleton(final FullQualifiedName entityContainer, final String singletonName) + throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlActionImport getActionImport(final FullQualifiedName entityContainer, final String actionImportName) + throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlFunctionImport getFunctionImport(final FullQualifiedName entityContainer, + final String functionImportName) + throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public CsdlEntityContainerInfo getEntityContainerInfo(final FullQualifiedName entityContainerName) + throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public List<CsdlAliasInfo> getAliasInfos() throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + + @Override + public List<CsdlSchema> getSchemas() throws ODataException { + CsdlSchema providerSchema = new CsdlSchema(); + providerSchema.setNamespace(NAMESPACE); + providerSchema.setAlias(ALIAS); + CsdlEntityContainer container = new CsdlEntityContainer().setName("container"); + + List<CsdlEntitySet> entitySets = new ArrayList<CsdlEntitySet>(); + entitySets.add(new CsdlEntitySet().setName("entitySetName") + .setType(new FullQualifiedName(NAMESPACE, "entityType1"))); + entitySets + .add(new CsdlEntitySet().setName("entitySetName2").setType(new FullQualifiedName(NAMESPACE, "entityType2"))); + container.setEntitySets(entitySets); + + List<CsdlSingleton> singletons = new ArrayList<CsdlSingleton>(); + singletons.add(new CsdlSingleton().setName("singletonName") + .setType(new FullQualifiedName(NAMESPACE, "entityType1"))); + singletons + .add(new CsdlSingleton().setName("singletonName2").setType(new FullQualifiedName(NAMESPACE, "entityType2"))); + container.setSingletons(singletons); + + List<CsdlActionImport> actionImports = new ArrayList<CsdlActionImport>(); + actionImports.add(new CsdlActionImport().setName("actionImportName").setAction( + new FullQualifiedName(NAMESPACE, "action1"))); + actionImports.add(new CsdlActionImport().setName("actionImportName2").setAction( + new FullQualifiedName(NAMESPACE, "action2"))); + container.setActionImports(actionImports); + + List<CsdlFunctionImport> functionImports = new ArrayList<CsdlFunctionImport>(); + functionImports.add(new CsdlFunctionImport().setName("functionImportName").setFunction( + new FullQualifiedName(NAMESPACE, "function1"))); + functionImports.add(new CsdlFunctionImport().setName("functionImportName2").setFunction( + new FullQualifiedName(NAMESPACE, "function2"))); + container.setFunctionImports(functionImports); + providerSchema.setEntityContainer(container); + + List<CsdlTypeDefinition> typeDefinitions = new ArrayList<CsdlTypeDefinition>(); + typeDefinitions.add(new CsdlTypeDefinition().setName("typeDefinition1").setUnderlyingType( + EdmPrimitiveTypeKind.String.getFullQualifiedName())); + typeDefinitions.add(new CsdlTypeDefinition().setName("typeDefinition2").setUnderlyingType( + EdmPrimitiveTypeKind.String.getFullQualifiedName())); + providerSchema.setTypeDefinitions(typeDefinitions); + + List<CsdlEnumType> enumTypes = new ArrayList<CsdlEnumType>(); + enumTypes.add(new CsdlEnumType().setName("enumType1")); + enumTypes.add(new CsdlEnumType().setName("enumType2")); + providerSchema.setEnumTypes(enumTypes); + + List<CsdlEntityType> entityTypes = new ArrayList<CsdlEntityType>(); + entityTypes.add(new CsdlEntityType().setName("entityType1")); + entityTypes.add(new CsdlEntityType().setName("entityType2") + .setBaseType(new FullQualifiedName(NAMESPACE, "entityType1"))); + providerSchema.setEntityTypes(entityTypes); + + List<CsdlComplexType> complexTypes = new ArrayList<CsdlComplexType>(); + complexTypes.add(new CsdlComplexType().setName("complexType1")); + complexTypes.add(new CsdlComplexType().setName("complexType2").setBaseType( + new FullQualifiedName(NAMESPACE, "complexType1"))); + providerSchema.setComplexTypes(complexTypes); + + List<CsdlAction> actions = new ArrayList<CsdlAction>(); + actions.add(new CsdlAction().setName("action1")); + actions.add(new CsdlAction().setName("action2")); + providerSchema.setActions(actions); + + List<CsdlFunction> functions = new ArrayList<CsdlFunction>(); + functions.add(new CsdlFunction().setName("function1")); + functions.add(new CsdlFunction().setName("function2")); + providerSchema.setFunctions(functions); + ArrayList<CsdlSchema> schemas = new ArrayList<CsdlSchema>(); + schemas.add(providerSchema); + return schemas; + } + + @Override + public CsdlEntityContainer getEntityContainer() throws ODataException { + throw new RuntimeException("Provider must not be called in the schema case"); + } + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/9c1981c4/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSingletonImplTest.java ---------------------------------------------------------------------- diff --git a/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSingletonImplTest.java b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSingletonImplTest.java new file mode 100644 index 0000000..d1aeb20 --- /dev/null +++ b/lib/commons-core/src/test/java/org/apache/olingo/server/core/edm/provider/EdmSingletonImplTest.java @@ -0,0 +1,131 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.olingo.server.core.edm.provider; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.Arrays; + +import org.apache.olingo.commons.api.edm.EdmBindingTarget; +import org.apache.olingo.commons.api.edm.EdmEntityContainer; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmException; +import org.apache.olingo.commons.api.edm.EdmSingleton; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.provider.CsdlEdmProvider; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityContainerInfo; +import org.apache.olingo.commons.api.edm.provider.CsdlEntityType; +import org.apache.olingo.commons.api.edm.provider.CsdlNavigationPropertyBinding; +import org.apache.olingo.commons.api.edm.provider.CsdlPropertyRef; +import org.apache.olingo.commons.api.edm.provider.CsdlSingleton; +import org.apache.olingo.commons.core.edm.EdmEntityContainerImpl; +import org.apache.olingo.commons.core.edm.EdmProviderImpl; +import org.apache.olingo.commons.core.edm.EdmSingletonImpl; +import org.junit.Test; + +public class EdmSingletonImplTest { + + @Test + public void singleton() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + + final FullQualifiedName typeName = new FullQualifiedName("ns", "entityType"); + final CsdlEntityType entityTypeProvider = new CsdlEntityType() + .setName(typeName.getName()) + .setKey(Arrays.asList(new CsdlPropertyRef().setName("Id"))); + when(provider.getEntityType(typeName)).thenReturn(entityTypeProvider); + + final FullQualifiedName containerName = new FullQualifiedName("ns", "container"); + final CsdlEntityContainerInfo containerInfo = new CsdlEntityContainerInfo().setContainerName(containerName); + when(provider.getEntityContainerInfo(containerName)).thenReturn(containerInfo); + final EdmEntityContainer entityContainer = new EdmEntityContainerImpl(edm, provider, containerInfo); + + final String singletonName = "singleton"; + final CsdlSingleton singletonProvider = + new CsdlSingleton() + .setName(singletonName) + .setType(typeName) + .setNavigationPropertyBindings( + Arrays.asList( + new CsdlNavigationPropertyBinding().setPath("path").setTarget( + containerName.getFullQualifiedNameAsString() + "/" + singletonName))); + when(provider.getSingleton(containerName, singletonName)).thenReturn(singletonProvider); + + final EdmSingleton singleton = new EdmSingletonImpl(edm, entityContainer, singletonProvider); + assertEquals(singletonName, entityContainer.getSingleton(singletonName).getName()); + assertEquals(singletonName, singleton.getName()); + final EdmEntityType entityType = singleton.getEntityType(); + assertEquals(typeName.getNamespace(), entityType.getNamespace()); + assertEquals(typeName.getName(), entityType.getName()); + assertEquals(entityContainer, singleton.getEntityContainer()); + assertNull(singleton.getRelatedBindingTarget(null)); + final EdmBindingTarget target = singleton.getRelatedBindingTarget("path"); + assertEquals(singletonName, target.getName()); + } + + @Test(expected = EdmException.class) + public void wrongTarget() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + + final FullQualifiedName containerName = new FullQualifiedName("ns", "container"); + final CsdlEntityContainerInfo containerInfo = new CsdlEntityContainerInfo().setContainerName(containerName); + when(provider.getEntityContainerInfo(containerName)).thenReturn(containerInfo); + + final String singletonName = "singleton"; + final CsdlSingleton singletonProvider = new CsdlSingleton() + .setNavigationPropertyBindings(Arrays.asList( + new CsdlNavigationPropertyBinding().setPath("path") + .setTarget(containerName.getFullQualifiedNameAsString() + "/wrong"))); + when(provider.getSingleton(containerName, singletonName)).thenReturn(singletonProvider); + + final EdmSingleton singleton = new EdmSingletonImpl(edm, null, singletonProvider); + singleton.getRelatedBindingTarget("path"); + } + + @Test(expected = EdmException.class) + public void wrongTargetContainer() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + + final FullQualifiedName containerName = new FullQualifiedName("ns", "container"); + final String singletonName = "singleton"; + final CsdlSingleton singletonProvider = new CsdlSingleton() + .setNavigationPropertyBindings(Arrays.asList( + new CsdlNavigationPropertyBinding().setPath("path").setTarget("ns.wrongContainer/" + singletonName))); + when(provider.getSingleton(containerName, singletonName)).thenReturn(singletonProvider); + + final EdmSingleton singleton = new EdmSingletonImpl(edm, null, singletonProvider); + singleton.getRelatedBindingTarget("path"); + } + + @Test(expected = EdmException.class) + public void nonExsistingEntityType() throws Exception { + CsdlEdmProvider provider = mock(CsdlEdmProvider.class); + EdmProviderImpl edm = new EdmProviderImpl(provider); + + CsdlSingleton singleton = new CsdlSingleton().setName("name"); + final EdmSingleton edmSingleton = new EdmSingletonImpl(edm, null, singleton); + edmSingleton.getEntityType(); + } +}
