http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/554c795e/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/json/ServiceDocumentTest.java ---------------------------------------------------------------------- diff --git a/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/json/ServiceDocumentTest.java b/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/json/ServiceDocumentTest.java new file mode 100644 index 0000000..4bf5a99 --- /dev/null +++ b/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/json/ServiceDocumentTest.java @@ -0,0 +1,133 @@ +/* + * 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.serializer.json; + +import static org.junit.Assert.assertFalse; +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.io.InputStream; +import java.util.ArrayList; +import java.util.List; + +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmEntityContainer; +import org.apache.olingo.commons.api.edm.EdmEntitySet; +import org.apache.olingo.commons.api.edm.EdmFunctionImport; +import org.apache.olingo.commons.api.edm.EdmSingleton; +import org.apache.olingo.server.api.ODataServer; +import org.apache.olingo.server.api.serializer.ODataFormat; +import org.apache.olingo.server.api.serializer.ODataSerializer; +import org.apache.olingo.server.core.testutil.StringUtils; +import org.junit.Before; +import org.junit.Test; + +public class ServiceDocumentTest { + + private Edm edm; + + @Before + public void before() { + + EdmEntitySet edmEntitySet1 = mock(EdmEntitySet.class); + when(edmEntitySet1.getName()).thenReturn("entitySetName1"); + when(edmEntitySet1.isIncludeInServiceDocument()).thenReturn(true); + + EdmEntitySet edmEntitySet2 = mock(EdmEntitySet.class); + when(edmEntitySet2.getName()).thenReturn("entitySetName2"); + when(edmEntitySet2.isIncludeInServiceDocument()).thenReturn(true); + + EdmEntitySet edmEntitySet3 = mock(EdmEntitySet.class); + when(edmEntitySet3.getName()).thenReturn("entitySetName3"); + when(edmEntitySet3.isIncludeInServiceDocument()).thenReturn(false); + + List<EdmEntitySet> entitySets = new ArrayList<EdmEntitySet>(); + entitySets.add(edmEntitySet1); + entitySets.add(edmEntitySet2); + entitySets.add(edmEntitySet3); + + EdmFunctionImport functionImport1 = mock(EdmFunctionImport.class); + when(functionImport1.getName()).thenReturn("functionImport1"); + when(functionImport1.isIncludeInServiceDocument()).thenReturn(true); + + EdmFunctionImport functionImport2 = mock(EdmFunctionImport.class); + when(functionImport2.getName()).thenReturn("functionImport2"); + when(functionImport2.isIncludeInServiceDocument()).thenReturn(true); + + EdmFunctionImport functionImport3 = mock(EdmFunctionImport.class); + when(functionImport3.getName()).thenReturn("functionImport3"); + when(functionImport3.isIncludeInServiceDocument()).thenReturn(false); + + List<EdmFunctionImport> functionImports = new ArrayList<EdmFunctionImport>(); + functionImports.add(functionImport1); + functionImports.add(functionImport2); + functionImports.add(functionImport3); + + EdmSingleton singleton1 = mock(EdmSingleton.class); + when(singleton1.getName()).thenReturn("singleton1"); + + EdmSingleton singleton2 = mock(EdmSingleton.class); + when(singleton2.getName()).thenReturn("singleton2"); + + EdmSingleton singleton3 = mock(EdmSingleton.class); + when(singleton3.getName()).thenReturn("singleton3"); + + List<EdmSingleton> singletons = new ArrayList<EdmSingleton>(); + singletons.add(singleton1); + singletons.add(singleton2); + singletons.add(singleton3); + + EdmEntityContainer edmEntityContainer = mock(EdmEntityContainer.class); + when(edmEntityContainer.getEntitySets()).thenReturn(entitySets); + when(edmEntityContainer.getFunctionImports()).thenReturn(functionImports); + when(edmEntityContainer.getSingletons()).thenReturn(singletons); + + edm = mock(Edm.class); + when(edm.getEntityContainer(null)).thenReturn(edmEntityContainer); + } + + @Test + public void writeServiceDocumentJson() throws Exception { + String serviceRoot = "http://localhost:8080/odata.svc";; + + ODataServer server = ODataServer.newInstance(); + assertNotNull(server); + + ODataSerializer serializer = server.getSerializer(ODataFormat.JSON); + assertNotNull(serializer); + + InputStream result = serializer.serviceDocument(edm, serviceRoot); + assertNotNull(result); + String jsonString = StringUtils.inputStreamToString(result, true); + + assertTrue(jsonString.contains("entitySetName1")); + assertTrue(jsonString.contains("entitySetName2")); + assertFalse(jsonString.contains("entitySetName3")); + + assertTrue(jsonString.contains("functionImport1")); + assertTrue(jsonString.contains("functionImport2")); + assertFalse(jsonString.contains("functionImport3")); + + assertTrue(jsonString.contains("singleton1")); + assertTrue(jsonString.contains("singleton2")); + assertTrue(jsonString.contains("singleton3")); + } +}
http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/554c795e/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/xml/MetadataDocumentTest.java ---------------------------------------------------------------------- diff --git a/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/xml/MetadataDocumentTest.java b/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/xml/MetadataDocumentTest.java new file mode 100644 index 0000000..6a19364 --- /dev/null +++ b/lib/ref/src/test/java/org/apache/olingo/server/core/serializer/xml/MetadataDocumentTest.java @@ -0,0 +1,252 @@ +/* + * 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.serializer.xml; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; + +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.olingo.commons.api.ODataException; +import org.apache.olingo.commons.api.ODataRuntimeException; +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmPrimitiveTypeKind; +import org.apache.olingo.commons.api.edm.FullQualifiedName; +import org.apache.olingo.commons.api.edm.Target; +import org.apache.olingo.server.api.ODataServer; +import org.apache.olingo.server.api.edm.provider.Action; +import org.apache.olingo.server.api.edm.provider.ActionImport; +import org.apache.olingo.server.api.edm.provider.ComplexType; +import org.apache.olingo.server.api.edm.provider.EdmProvider; +import org.apache.olingo.server.api.edm.provider.EntityContainer; +import org.apache.olingo.server.api.edm.provider.EntitySet; +import org.apache.olingo.server.api.edm.provider.EntityType; +import org.apache.olingo.server.api.edm.provider.EnumMember; +import org.apache.olingo.server.api.edm.provider.EnumType; +import org.apache.olingo.server.api.edm.provider.Function; +import org.apache.olingo.server.api.edm.provider.FunctionImport; +import org.apache.olingo.server.api.edm.provider.NavigationProperty; +import org.apache.olingo.server.api.edm.provider.NavigationPropertyBinding; +import org.apache.olingo.server.api.edm.provider.Parameter; +import org.apache.olingo.server.api.edm.provider.Property; +import org.apache.olingo.server.api.edm.provider.ReturnType; +import org.apache.olingo.server.api.edm.provider.Schema; +import org.apache.olingo.server.api.edm.provider.Singleton; +import org.apache.olingo.server.api.edm.provider.TypeDefinition; +import org.apache.olingo.server.api.serializer.ODataFormat; +import org.apache.olingo.server.api.serializer.ODataSerializer; +import org.apache.olingo.server.core.edm.provider.EdmProviderImpl; +import org.apache.olingo.server.core.testutil.StringUtils; +import org.apache.olingo.server.core.testutil.techprovider.EdmTechProvider; +import org.junit.Test; + +public class MetadataDocumentTest { + + @Test(expected = ODataRuntimeException.class) + public void metadataOnJsonResultsInException() { + ODataSerializer serializer = ODataServer.newInstance().getSerializer(ODataFormat.JSON); + serializer.metadataDocument(mock(Edm.class)); + } + + @Test + public void writeMetadataWithEmptyMockedEdm() { + ODataSerializer serializer = ODataServer.newInstance().getSerializer(ODataFormat.XML); + Edm edm = mock(Edm.class); + serializer.metadataDocument(edm); + } + + @Test + public void writeMetadataWithLocalTestEdm() { + ODataSerializer serializer = ODataServer.newInstance().getSerializer(ODataFormat.XML); + Edm edm = new EdmProviderImpl(new TestMetadataProvider()); + InputStream metadata = serializer.metadataDocument(edm); + assertNotNull(metadata); + String metadataString = StringUtils.inputStreamToString(metadata, false); + assertTrue(metadataString + .contains("<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\";>")); + + assertTrue(metadataString + .contains("<Schema xmlns=\"http://docs.oasis-open.org/odata/ns/edm\"; " + + "Namespace=\"namespace\" Alias=\"alias\">")); + + assertTrue(metadataString + .contains("<EntityType Name=\"ETBaseName\"><Property Name=\"P1\" Type=\"Edm.Int16\"/><NavigationProperty " + + "Name=\"N1\" Type=\"namespace.ETBaseName\" Nullable=\"true\" Partner=\"N1\"/></EntityType>")); + + assertTrue(metadataString + .contains("<EntityType Name=\"ETDerivedName\" BaseType=\"namespace.ETBaseName\"><Property Name=\"P2\" " + + "Type=\"Edm.Int16\"/><NavigationProperty Name=\"N2\" Type=\"namespace.ETDerivedName\" Nullable=\"true\" " + + "Partner=\"N2\"/></EntityType>")); + + assertTrue(metadataString + .contains("<ComplexType Name=\"CTBaseName\"><Property Name=\"P1\" Type=\"Edm.Int16\"/><NavigationProperty " + + "Name=\"N1\" Type=\"namespace.ETBaseName\" Nullable=\"true\" Partner=\"N1\"/></ComplexType>")); + + assertTrue(metadataString + .contains("<ComplexType Name=\"CTDerivedName\" BaseType=\"namespace.CTBaseName\"><Property Name=\"P2\" " + + "Type=\"Edm.Int16\"/><NavigationProperty Name=\"N2\" Type=\"namespace.ETDerivedName\" Nullable=\"true\" " + + "Partner=\"N2\"/></ComplexType>")); + + assertTrue(metadataString.contains("<TypeDefinition Name=\"typeDef\" Type=\"Edm.Int16\"/>")); + + assertTrue(metadataString.contains("<Action Name=\"ActionWOParameter\" IsBound=\"false\"/>")); + + assertTrue(metadataString + .contains("<Action Name=\"ActionName\" IsBound=\"true\"><Parameter Name=\"param\" Type=\"Edm.Int16\"/>" + + "<Parameter Name=\"param2\" Type=\"Collection(Edm.Int16)\"/><ReturnType Type=\"namespace.CTBaseName\"/>" + + "</Action>")); + + assertTrue(metadataString + .contains("<Function Name=\"FunctionWOParameter\" IsBound=\"false\" IsComposable=\"false\"><ReturnType " + + "Type=\"namespace.CTBaseName\"/></Function>")); + + assertTrue(metadataString + .contains("<Function Name=\"FunctionName\" IsBound=\"true\" IsComposable=\"false\"><Parameter Name=\"param\" " + + "Type=\"Edm.Int16\"/><Parameter Name=\"param2\" Type=\"Collection(Edm.Int16)\"/><ReturnType " + + "Type=\"namespace.CTBaseName\"/></Function>")); + + assertTrue(metadataString.contains("<EntityContainer Name=\"container\">")); + + assertTrue(metadataString + .contains("<EntitySet Name=\"EntitySetName\" EntityType=\"namespace.ETBaseName\"><NavigationPropertyBinding " + + "Path=\"N1\" Target=\"namespace.container/EntitySetName\"/></EntitySet>")); + assertTrue(metadataString + .contains("<Singleton Name=\"SingletonName\" EntityType=\"namespace.ETBaseName\"><NavigationPropertyBinding " + + "Path=\"N1\" Target=\"namespace.container/EntitySetName\"/></Singleton>")); + + assertTrue(metadataString.contains("<ActionImport Name=\"actionImport\" Action=\"namespace.ActionWOParameter\"/>")); + + assertTrue(metadataString + .contains("<FunctionImport Name=\"actionImport\" Function=\"namespace.FunctionName\" " + + "EntitySet=\"namespace.EntitySetName\" IncludeInServiceDocument=\"false\"/>")); + + assertTrue(metadataString.contains("</EntityContainer></Schema></edmx:DataServices></edmx:Edmx>")); + } + + @Test + public void writeMetadataWithTechnicalScenario() { + ODataSerializer serializer = ODataServer.newInstance().getSerializer(ODataFormat.XML); + EdmProviderImpl edm = new EdmProviderImpl(new EdmTechProvider()); + InputStream metadata = serializer.metadataDocument(edm); + assertNotNull(metadata); + // The technical scenario is too big to verify. We are content for now to make sure we can serialize it. + // System.out.println(StringUtils.inputStreamToString(metadata, false)); + } + + private class TestMetadataProvider extends EdmProvider { + + @Override + public List<Schema> getSchemas() throws ODataException { + Property p1 = new Property().setName("P1").setType(EdmPrimitiveTypeKind.Int16.getFullQualifiedName()); + String ns = "namespace"; + NavigationProperty n1 = new NavigationProperty().setName("N1") + .setType(new FullQualifiedName(ns, "ETBaseName")).setNullable(true).setPartner("N1"); + Property p2 = new Property().setName("P2").setType(EdmPrimitiveTypeKind.Int16.getFullQualifiedName()); + NavigationProperty n2 = new NavigationProperty().setName("N2") + .setType(new FullQualifiedName(ns, "ETDerivedName")).setNullable(true).setPartner("N2"); + Schema schema = new Schema().setNamespace(ns).setAlias("alias"); + List<ComplexType> complexTypes = new ArrayList<ComplexType>(); + schema.setComplexTypes(complexTypes); + ComplexType ctBase = + new ComplexType().setName("CTBaseName").setProperties(Arrays.asList(p1)).setNavigationProperties( + Arrays.asList(n1)); + complexTypes.add(ctBase); + ComplexType ctDerived = + new ComplexType().setName("CTDerivedName").setBaseType(new FullQualifiedName(ns, "CTBaseName")) + .setProperties(Arrays.asList(p2)).setNavigationProperties(Arrays.asList(n2)); + complexTypes.add(ctDerived); + + List<EntityType> entityTypes = new ArrayList<EntityType>(); + schema.setEntityTypes(entityTypes); + EntityType etBase = + new EntityType().setName("ETBaseName").setProperties(Arrays.asList(p1)).setNavigationProperties( + Arrays.asList(n1)); + entityTypes.add(etBase); + EntityType etDerived = + new EntityType().setName("ETDerivedName").setBaseType(new FullQualifiedName(ns, "ETBaseName")) + .setProperties(Arrays.asList(p2)).setNavigationProperties(Arrays.asList(n2)); + entityTypes.add(etDerived); + + List<Action> actions = new ArrayList<Action>(); + schema.setActions(actions); + // TODO:EntitySetPath + actions.add((new Action().setName("ActionWOParameter"))); + List<Parameter> parameters = new ArrayList<Parameter>(); + parameters.add(new Parameter().setName("param").setType(EdmPrimitiveTypeKind.Int16.getFullQualifiedName())); + parameters.add(new Parameter().setName("param2").setType(EdmPrimitiveTypeKind.Int16.getFullQualifiedName()) + .setCollection(true)); + actions.add(new Action().setName("ActionName").setBound(true).setParameters(parameters).setReturnType( + new ReturnType().setType(new FullQualifiedName(ns, "CTBaseName")))); + + List<Function> functions = new ArrayList<Function>(); + schema.setFunctions(functions); + functions.add((new Function().setName("FunctionWOParameter") + .setReturnType(new ReturnType().setType(new FullQualifiedName(ns, "CTBaseName"))))); + functions.add(new Function().setName("FunctionName").setBound(true).setParameters(parameters).setReturnType( + new ReturnType().setType(new FullQualifiedName(ns, "CTBaseName")))); + + List<EnumType> enumTypes = new ArrayList<EnumType>(); + schema.setEnumTypes(enumTypes); + List<EnumMember> members = new ArrayList<EnumMember>(); + members.add(new EnumMember().setName("member").setValue("1")); + enumTypes.add(new EnumType().setName("EnumName").setFlags(true).setMembers(members)); + + List<TypeDefinition> typeDefinitions = new ArrayList<TypeDefinition>(); + schema.setTypeDefinitions(typeDefinitions); + typeDefinitions.add(new TypeDefinition().setName("typeDef") + .setUnderlyingType(EdmPrimitiveTypeKind.Int16.getFullQualifiedName())); + + EntityContainer container = new EntityContainer().setName("container"); + schema.setEntityContainer(container); + + List<ActionImport> actionImports = new ArrayList<ActionImport>(); + container.setActionImports(actionImports); + actionImports.add(new ActionImport().setName("actionImport").setAction( + new FullQualifiedName(ns, "ActionWOParameter")).setEntitySet( + new Target().setEntityContainer(new FullQualifiedName(ns, "container")).setTargetName("EntitySetName"))); + + List<FunctionImport> functionImports = new ArrayList<FunctionImport>(); + container.setFunctionImports(functionImports); + functionImports.add(new FunctionImport().setName("actionImport").setFunction( + new FullQualifiedName(ns, "FunctionName")).setEntitySet( + new Target().setEntityContainer(new FullQualifiedName(ns, "container")).setTargetName("EntitySetName"))); + + List<EntitySet> entitySets = new ArrayList<EntitySet>(); + container.setEntitySets(entitySets); + List<NavigationPropertyBinding> nPB = new ArrayList<NavigationPropertyBinding>(); + nPB.add(new NavigationPropertyBinding().setPath("N1").setTarget( + new Target().setEntityContainer(new FullQualifiedName(ns, "container")).setTargetName("EntitySetName"))); + entitySets.add(new EntitySet().setName("EntitySetName").setType(new FullQualifiedName(ns, "ETBaseName")) + .setNavigationPropertyBindings(nPB)); + + List<Singleton> singletons = new ArrayList<Singleton>(); + container.setSingletons(singletons); + singletons.add(new Singleton().setName("SingletonName").setType(new FullQualifiedName(ns, "ETBaseName")) + .setNavigationPropertyBindings(nPB)); + + List<Schema> schemas = new ArrayList<Schema>(); + schemas.add(schema); + return schemas; + } + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/554c795e/lib/ref/src/test/java/org/apache/olingo/server/core/uri/RawUriTest.java ---------------------------------------------------------------------- diff --git a/lib/ref/src/test/java/org/apache/olingo/server/core/uri/RawUriTest.java b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/RawUriTest.java new file mode 100644 index 0000000..f54ad57 --- /dev/null +++ b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/RawUriTest.java @@ -0,0 +1,151 @@ +/* + * 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.uri; + +import static org.junit.Assert.assertEquals; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import org.apache.olingo.server.core.uri.parser.RawUri; +import org.apache.olingo.server.core.uri.parser.UriDecoder; +import org.apache.olingo.server.core.uri.parser.UriParserSyntaxException; +import org.junit.Test; + +public class RawUriTest { + + private RawUri runRawParser(final String uri, final int scipSegments) throws UriParserSyntaxException { + return UriDecoder.decodeUri(uri, scipSegments); + } + + @Test + public void testOption() throws Exception { + RawUri rawUri; + rawUri = runRawParser("?", 0); + checkOptionCount(rawUri, 0); + + rawUri = runRawParser("?a", 0); + checkOption(rawUri, 0, "a", ""); + + rawUri = runRawParser("?a=b", 0); + checkOption(rawUri, 0, "a", "b"); + + rawUri = runRawParser("?=", 0); + checkOption(rawUri, 0, "", ""); + + rawUri = runRawParser("?=b", 0); + checkOption(rawUri, 0, "", "b"); + + rawUri = runRawParser("?a&c", 0); + checkOption(rawUri, 0, "a", ""); + checkOption(rawUri, 1, "c", ""); + + rawUri = runRawParser("?a=b&c", 0); + checkOption(rawUri, 0, "a", "b"); + checkOption(rawUri, 1, "c", ""); + + rawUri = runRawParser("?a=b&c=d", 0); + checkOption(rawUri, 0, "a", "b"); + checkOption(rawUri, 1, "c", "d"); + + rawUri = runRawParser("?=&=", 0); + checkOption(rawUri, 0, "", ""); + checkOption(rawUri, 1, "", ""); + + rawUri = runRawParser("?=&c=d", 0); + checkOption(rawUri, 0, "", ""); + checkOption(rawUri, 1, "c", "d"); + } + + private void checkOption(final RawUri rawUri, final int index, final String name, final String value) { + RawUri.QueryOption option = rawUri.queryOptionListDecoded.get(index); + + assertEquals(name, option.name); + assertEquals(value, option.value); + + } + + private void checkOptionCount(final RawUri rawUri, final int count) { + assertEquals(count, rawUri.queryOptionListDecoded.size()); + } + + @Test + public void testPath() throws Exception { + RawUri rawUri; + + rawUri = runRawParser("http://test.org";, 0); + checkPath(rawUri, "", new ArrayList<String>()); + + rawUri = runRawParser("http://test.org/";, 0); + checkPath(rawUri, "/", Arrays.asList("")); + + rawUri = runRawParser("http://test.org/entitySet";, 0); + checkPath(rawUri, "/entitySet", Arrays.asList("entitySet")); + + rawUri = runRawParser("http://test.org/nonServiceSegment/entitySet";, 0); + checkPath(rawUri, "/nonServiceSegment/entitySet", Arrays.asList("nonServiceSegment", "entitySet")); + + rawUri = runRawParser("http://test.org/nonServiceSegment/entitySet";, 1); + checkPath(rawUri, "/nonServiceSegment/entitySet", Arrays.asList("entitySet")); + + rawUri = runRawParser("", 0); + checkPath(rawUri, "", new ArrayList<String>()); + + rawUri = runRawParser("/", 0); + checkPath(rawUri, "/", Arrays.asList("")); + + rawUri = runRawParser("/entitySet", 0); + checkPath(rawUri, "/entitySet", Arrays.asList("entitySet")); + + rawUri = runRawParser("entitySet", 0); + checkPath(rawUri, "entitySet", Arrays.asList("entitySet")); + + rawUri = runRawParser("nonServiceSegment/entitySet", 0); + checkPath(rawUri, "nonServiceSegment/entitySet", Arrays.asList("nonServiceSegment", "entitySet")); + + rawUri = runRawParser("nonServiceSegment/entitySet", 1); + checkPath(rawUri, "nonServiceSegment/entitySet", Arrays.asList("entitySet")); + + rawUri = runRawParser("http://test.org/a?abc=xx+yz";, 0); + } + + @Test + public void testSplitt() { + UriDecoder.splitt("", '/'); + UriDecoder.splitt("/", '/'); + UriDecoder.splitt("a", '/'); + UriDecoder.splitt("a/", '/'); + UriDecoder.splitt("/a", '/'); + UriDecoder.splitt("a/a", '/'); + } + + private void checkPath(final RawUri rawUri, final String path, final List<String> list) { + assertEquals(path, rawUri.path); + + assertEquals(list.size(), rawUri.pathSegmentListDecoded.size()); + + int i = 0; + while (i < list.size()) { + assertEquals(list.get(i), rawUri.pathSegmentListDecoded.get(i)); + i++; + } + } + +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/554c795e/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriInfoImplTest.java ---------------------------------------------------------------------- diff --git a/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriInfoImplTest.java b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriInfoImplTest.java new file mode 100644 index 0000000..a9d516d --- /dev/null +++ b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriInfoImplTest.java @@ -0,0 +1,201 @@ +/* + * 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.uri; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.olingo.commons.api.edm.Edm; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.server.api.uri.UriInfoAll; +import org.apache.olingo.server.api.uri.UriInfoBatch; +import org.apache.olingo.server.api.uri.UriInfoCrossjoin; +import org.apache.olingo.server.api.uri.UriInfoEntityId; +import org.apache.olingo.server.api.uri.UriInfoKind; +import org.apache.olingo.server.api.uri.UriInfoMetadata; +import org.apache.olingo.server.api.uri.UriInfoResource; +import org.apache.olingo.server.api.uri.UriInfoService; +import org.apache.olingo.server.api.uri.queryoption.CustomQueryOption; +import org.apache.olingo.server.core.edm.provider.EdmProviderImpl; +import org.apache.olingo.server.core.testutil.EdmTechTestProvider; +import org.apache.olingo.server.core.testutil.techprovider.EntityTypeProvider; +import org.apache.olingo.server.core.uri.queryoption.CountOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.CustomQueryOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.ExpandOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.FilterOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.FormatOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.IdOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.LevelsOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.OrderByOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.QueryOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.SearchOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.SelectOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.SkipOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.SkipTokenOptionImpl; +import org.apache.olingo.server.core.uri.queryoption.TopOptionImpl; +import org.junit.Test; + +public class UriInfoImplTest { + + Edm edm = new EdmProviderImpl(new EdmTechTestProvider()); + + @Test + public void testKind() { + UriInfoImpl uriInfo = new UriInfoImpl().setKind(UriInfoKind.all); + assertEquals(UriInfoKind.all, uriInfo.getKind()); + } + + @Test + public void testCasts() { + UriInfoImpl uriInfo = new UriInfoImpl(); + + UriInfoAll all = uriInfo.asUriInfoAll(); + assertEquals(uriInfo, all); + + UriInfoBatch batch = uriInfo.asUriInfoBatch(); + assertEquals(uriInfo, batch); + + UriInfoCrossjoin crossjoin = uriInfo.asUriInfoCrossjoin(); + assertEquals(uriInfo, crossjoin); + + UriInfoEntityId entityID = uriInfo.asUriInfoEntityId(); + assertEquals(uriInfo, entityID); + + UriInfoMetadata metadata = uriInfo.asUriInfoMetadata(); + assertEquals(uriInfo, metadata); + + UriInfoResource resource = uriInfo.asUriInfoResource(); + assertEquals(uriInfo, resource); + + UriInfoService service = uriInfo.asUriInfoService(); + assertEquals(uriInfo, service); + + } + + @Test + public void testEntityNames() { + UriInfoImpl uriInfo = new UriInfoImpl(); + uriInfo.addEntitySetName("A"); + uriInfo.addEntitySetName("B"); + + assertEquals("A", uriInfo.getEntitySetNames().get(0)); + assertEquals("B", uriInfo.getEntitySetNames().get(1)); + + } + + @Test + public void testResourceParts() { + UriInfoImpl uriInfo = new UriInfoImpl(); + + UriResourceActionImpl action = new UriResourceActionImpl(); + UriResourceEntitySetImpl entitySet0 = new UriResourceEntitySetImpl(); + UriResourceEntitySetImpl entitySet1 = new UriResourceEntitySetImpl(); + + uriInfo.addResourcePart(action); + uriInfo.addResourcePart(entitySet0); + + assertEquals(action, uriInfo.getUriResourceParts().get(0)); + assertEquals(entitySet0, uriInfo.getUriResourceParts().get(1)); + + assertEquals(entitySet0, uriInfo.getLastResourcePart()); + + uriInfo.addResourcePart(entitySet1); + assertEquals(entitySet1, uriInfo.getLastResourcePart()); + } + + @Test + public void testCustomQueryOption() { + UriInfoImpl uriInfo = new UriInfoImpl(); + + List<QueryOptionImpl> queryOptions = new ArrayList<QueryOptionImpl>(); + + ExpandOptionImpl expand = new ExpandOptionImpl(); + FilterOptionImpl filter = new FilterOptionImpl(); + FormatOptionImpl format = new FormatOptionImpl(); + IdOptionImpl id = new IdOptionImpl(); + CountOptionImpl inlinecount = new CountOptionImpl(); + OrderByOptionImpl orderby = new OrderByOptionImpl(); + SearchOptionImpl search = new SearchOptionImpl(); + SelectOptionImpl select = new SelectOptionImpl(); + SkipOptionImpl skip = new SkipOptionImpl(); + SkipTokenOptionImpl skipToken = new SkipTokenOptionImpl(); + TopOptionImpl top = new TopOptionImpl(); + LevelsOptionImpl levels = new LevelsOptionImpl(); + + CustomQueryOptionImpl customOption0 = new CustomQueryOptionImpl(); + customOption0.setText("A"); + CustomQueryOptionImpl customOption1 = new CustomQueryOptionImpl(); + customOption1.setText("B"); + + QueryOptionImpl queryOption = new QueryOptionImpl(); + + queryOptions.add(expand); + queryOptions.add(filter); + queryOptions.add(format); + queryOptions.add(id); + queryOptions.add(inlinecount); + queryOptions.add(orderby); + queryOptions.add(search); + queryOptions.add(select); + queryOptions.add(skip); + queryOptions.add(skipToken); + queryOptions.add(top); + queryOptions.add(customOption0); + queryOptions.add(customOption1); + queryOptions.add(levels);// not stored + queryOptions.add(queryOption);// not stored + uriInfo.setQueryOptions(queryOptions); + + assertEquals(expand, uriInfo.getExpandOption()); + assertEquals(filter, uriInfo.getFilterOption()); + assertEquals(format, uriInfo.getFormatOption()); + assertEquals(id, uriInfo.getIdOption()); + assertEquals(inlinecount, uriInfo.getCountOption()); + assertEquals(orderby, uriInfo.getOrderByOption()); + assertEquals(search, uriInfo.getSearchOption()); + assertEquals(select, uriInfo.getSelectOption()); + assertEquals(skip, uriInfo.getSkipOption()); + assertEquals(skipToken, uriInfo.getSkipTokenOption()); + assertEquals(top, uriInfo.getTopOption()); + + List<CustomQueryOption> customQueryOptions = uriInfo.getCustomQueryOptions(); + assertEquals(customOption0, customQueryOptions.get(0)); + assertEquals(customOption1, customQueryOptions.get(1)); + } + + @Test + public void testFragment() { + UriInfoImpl uriInfo = new UriInfoImpl(); + uriInfo.setFragment("F"); + assertEquals("F", uriInfo.getFragment()); + } + + @Test + public void testEntityTypeCast() { + UriInfoImpl uriInfo = new UriInfoImpl(); + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETKeyNav); + assertNotNull(entityType); + + uriInfo.setEntityTypeCast(entityType); + assertEquals(entityType, uriInfo.getEntityTypeCast()); + } +} http://git-wip-us.apache.org/repos/asf/olingo-odata4/blob/554c795e/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriResourceImplTest.java ---------------------------------------------------------------------- diff --git a/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriResourceImplTest.java b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriResourceImplTest.java new file mode 100644 index 0000000..bd4ac68 --- /dev/null +++ b/lib/ref/src/test/java/org/apache/olingo/server/core/uri/UriResourceImplTest.java @@ -0,0 +1,508 @@ +/* + * 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.uri; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import java.util.ArrayList; +import java.util.Arrays; +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.EdmActionImport; +import org.apache.olingo.commons.api.edm.EdmEntityType; +import org.apache.olingo.commons.api.edm.EdmFunction; +import org.apache.olingo.commons.api.edm.EdmFunctionImport; +import org.apache.olingo.commons.api.edm.EdmNavigationProperty; +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.core.edm.primitivetype.EdmPrimitiveTypeFactory; +import org.apache.olingo.server.api.uri.UriResourceKind; +import org.apache.olingo.server.core.edm.provider.EdmComplexTypeImpl; +import org.apache.olingo.server.core.edm.provider.EdmEntitySetImpl; +import org.apache.olingo.server.core.edm.provider.EdmProviderImpl; +import org.apache.olingo.server.core.edm.provider.EdmSingletonImpl; +import org.apache.olingo.server.core.testutil.EdmTechTestProvider; +import org.apache.olingo.server.core.testutil.techprovider.ActionProvider; +import org.apache.olingo.server.core.testutil.techprovider.ComplexTypeProvider; +import org.apache.olingo.server.core.testutil.techprovider.EntityTypeProvider; +import org.apache.olingo.server.core.uri.queryoption.expression.ExpressionImpl; +import org.apache.olingo.server.core.uri.queryoption.expression.LiteralImpl; +import org.junit.Test; + +public class UriResourceImplTest { + + Edm edm = new EdmProviderImpl(new EdmTechTestProvider()); + + @Test + public void testUriParameterImpl() { + UriParameterImpl impl = new UriParameterImpl(); + ExpressionImpl expression = new LiteralImpl().setText("Expression"); + + impl.setText("Text"); + impl.setName("A"); + impl.setAlias("@A"); + impl.setExpression(expression); + + assertEquals("Text", impl.getText()); + assertEquals("A", impl.getName()); + assertEquals("@A", impl.getAlias()); + assertEquals(expression, impl.getExression()); + } + + @Test + public void testUriResourceActionImpl() { + UriResourceActionImpl impl = new UriResourceActionImpl(); + assertEquals(UriResourceKind.action, impl.getKind()); + assertEquals("", impl.toString()); + + // action + EdmAction action = edm.getUnboundAction(ActionProvider.nameUARTETParam); + impl.setAction(action); + assertEquals(action, impl.getAction()); + assertEquals(ActionProvider.nameUARTETParam.getName(), impl.toString()); + + // action import + impl = new UriResourceActionImpl(); + EdmActionImport actionImport = edm.getEntityContainer(null).getActionImport("AIRTPrimParam"); + impl.setActionImport(actionImport); + assertEquals(actionImport, impl.getActionImport()); + assertEquals(actionImport.getUnboundAction(), impl.getAction()); + assertEquals(false, impl.isCollection()); + assertEquals("AIRTPrimParam", impl.toString()); + assertEquals(actionImport.getUnboundAction().getReturnType().getType(), impl.getType()); + } + + @Test + public void testUriResourceLambdaAllImpl() { + UriResourceLambdaAllImpl impl = new UriResourceLambdaAllImpl(); + assertEquals(UriResourceKind.lambdaAll, impl.getKind()); + + ExpressionImpl expression = new LiteralImpl().setText("Expression"); + impl.setExpression(expression); + impl.setLamdaVariable("A"); + + assertEquals(false, impl.isCollection()); + assertEquals(expression, impl.getExpression()); + assertEquals("A", impl.getLambdaVariable()); + assertEquals(EdmPrimitiveTypeFactory.getInstance(EdmPrimitiveTypeKind.Boolean), impl.getType()); + assertEquals("all", impl.toString()); + } + + @Test + public void testUriResourceLambdaAnyImpl() { + UriResourceLambdaAnyImpl impl = new UriResourceLambdaAnyImpl(); + assertEquals(UriResourceKind.lambdaAny, impl.getKind()); + + ExpressionImpl expression = new LiteralImpl().setText("Expression"); + impl.setExpression(expression); + impl.setLamdaVariable("A"); + + assertEquals(false, impl.isCollection()); + assertEquals(expression, impl.getExpression()); + assertEquals("A", impl.getLamdaVariable()); + assertEquals(EdmPrimitiveTypeFactory.getInstance(EdmPrimitiveTypeKind.Boolean), impl.getType()); + assertEquals("any", impl.toString()); + } + + @Test + public void testUriResourceComplexPropertyImpl() { + UriResourceComplexPropertyImpl impl = new UriResourceComplexPropertyImpl(); + assertEquals(UriResourceKind.complexProperty, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETKeyNav); + EdmProperty property = (EdmProperty) entityType.getProperty("PropertyComplex"); + impl.setProperty(property); + + assertEquals(property, impl.getProperty()); + assertEquals(property.getName(), impl.toString()); + assertEquals(false, impl.isCollection()); + assertEquals(property.getType(), impl.getType()); + assertEquals(property.getType(), impl.getComplexType()); + impl.getComplexType(); + + EdmComplexTypeImpl complexTypeImplType = + (EdmComplexTypeImpl) edm.getComplexType(ComplexTypeProvider.nameCTBasePrimCompNav); + + impl.setTypeFilter(complexTypeImplType); + assertEquals(complexTypeImplType, impl.getTypeFilter()); + assertEquals(complexTypeImplType, impl.getComplexTypeFilter()); + impl.getComplexTypeFilter(); + + } + + @Test + public void testUriResourcePrimitivePropertyImpl() { + UriResourcePrimitivePropertyImpl impl = new UriResourcePrimitivePropertyImpl(); + assertEquals(UriResourceKind.primitiveProperty, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETKeyNav); + EdmProperty property = (EdmProperty) entityType.getProperty("PropertyInt16"); + impl.setProperty(property); + + assertEquals(property, impl.getProperty()); + assertEquals(property.getName(), impl.toString()); + assertEquals(false, impl.isCollection()); + assertEquals(property.getType(), impl.getType()); + } + + @Test + public void testUriResourceCountImpl() { + UriResourceCountImpl impl = new UriResourceCountImpl(); + assertEquals(UriResourceKind.count, impl.getKind()); + assertEquals("$count", impl.toString()); + } + + @Test + public void testUriResourceEntitySetImpl() { + UriResourceEntitySetImpl impl = new UriResourceEntitySetImpl(); + assertEquals(UriResourceKind.entitySet, impl.getKind()); + + EdmEntitySetImpl entitySet = (EdmEntitySetImpl) edm.getEntityContainer(null).getEntitySet("ESAllPrim"); + impl.setEntitSet(entitySet); + + assertEquals("ESAllPrim", impl.toString()); + assertEquals(entitySet, impl.getEntitySet()); + + assertEquals(entitySet.getEntityType(), impl.getType()); + assertEquals(entitySet.getEntityType(), impl.getEntityType()); + impl.getEntityType(); + + // is Collection + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(new ArrayList<UriParameterImpl>()); + assertEquals(false, impl.isCollection()); + } + + @Test + public void testUriResourceFunctionImpl() { + UriResourceFunctionImpl impl = new UriResourceFunctionImpl(); + assertEquals(UriResourceKind.function, impl.getKind()); + assertEquals("", impl.toString()); + + // function + EdmFunction function = (EdmFunction) edm.getEntityContainer(null).getFunctionImport("FINRTInt16") + .getUnboundFunction(new ArrayList<String>()); + assertNotNull(function); + impl.setFunction(function); + + assertEquals(function, impl.getFunction()); + assertEquals("UFNRTInt16", impl.toString()); + assertEquals(function.getReturnType().getType(), impl.getType()); + assertEquals(false, impl.isParameterListFilled()); + + // function import + impl = new UriResourceFunctionImpl(); + EdmFunctionImport functionImport = edm.getEntityContainer(null).getFunctionImport("FINRTInt16"); + impl.setFunctionImport(functionImport, new ArrayList<UriParameterImpl>()); + assertEquals(functionImport, impl.getFunctionImport()); + assertEquals("FINRTInt16", impl.toString()); + + // function collection + impl = new UriResourceFunctionImpl(); + functionImport = edm.getEntityContainer(null).getFunctionImport("FICRTESTwoKeyNavParam"); + assertNotNull(function); + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + impl.setFunctionImport(functionImport, Arrays.asList(parameter)); + assertEquals("FICRTESTwoKeyNavParam", impl.toString()); + + impl.setFunction(functionImport.getUnboundFunction(Arrays.asList("ParameterInt16"))); + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(new ArrayList<UriParameterImpl>()); + assertEquals(false, impl.isCollection()); + + assertEquals(parameter, impl.getParameters().get(0)); + assertEquals(true, impl.isParameterListFilled()); + } + + @Test + public void testUriResourceImplKeyPred() { + class Mock extends UriResourceWithKeysImpl { + + EdmType type; + + public Mock() { + super(UriResourceKind.action); + } + + @Override + public EdmType getType() { + return type; + } + + public Mock setType(final EdmType type) { + this.type = type; + return this; + } + + @Override + public boolean isCollection() { + return false; + } + + @Override + public String toString() { + return "mock"; + } + } + + Mock impl = new Mock(); + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + EdmEntityType entityTypeBaseColl = edm.getEntityType(EntityTypeProvider.nameETBaseTwoKeyNav); + EdmEntityType entityTypeBaseEntry = edm.getEntityType(EntityTypeProvider.nameETTwoBaseTwoKeyNav); + + impl.setType(entityType); + assertEquals(entityType, impl.getType()); + assertEquals("mock", impl.toString(false)); + assertEquals("mock", impl.toString(true)); + + // set both + impl.setCollectionTypeFilter(entityTypeBaseColl); + assertEquals(entityTypeBaseColl, impl.getTypeFilterOnCollection()); + assertEquals("mock", impl.toString(false)); + assertEquals("mock/com.sap.odata.test1.ETBaseTwoKeyNav", impl.toString(true)); + impl.setEntryTypeFilter(entityTypeBaseEntry); + assertEquals(entityTypeBaseEntry, impl.getTypeFilterOnEntry()); + assertEquals("mock", impl.toString(false)); + assertEquals("mock/com.sap.odata.test1.ETBaseTwoKeyNav/()com.sap.odata.test1.ETTwoBaseTwoKeyNav", + impl.toString(true)); + + // set entry + impl = new Mock(); + impl.setType(entityType); + impl.setEntryTypeFilter(entityTypeBaseEntry); + assertEquals(entityTypeBaseEntry, impl.getTypeFilterOnEntry()); + assertEquals("mock", impl.toString(false)); + assertEquals("mock/com.sap.odata.test1.ETTwoBaseTwoKeyNav", impl.toString(true)); + + // set collection + impl = new Mock(); + impl.setType(entityType); + impl.setCollectionTypeFilter(entityTypeBaseColl); + assertEquals(entityTypeBaseColl, impl.getTypeFilterOnCollection()); + assertEquals("mock", impl.toString(false)); + assertEquals("mock/com.sap.odata.test1.ETBaseTwoKeyNav", impl.toString(true)); + + impl = new Mock(); + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + List<UriParameterImpl> keyPredicates = new ArrayList<UriParameterImpl>(); + keyPredicates.add(parameter); + + impl.setKeyPredicates(keyPredicates); + assertNotNull(null, impl.getKeyPredicates()); + + } + + @Test + public void testUriResourceImplTyped() { + class Mock extends UriResourceTypedImpl { + + EdmType type; + + public Mock() { + super(UriResourceKind.action); + } + + @Override + public EdmType getType() { + return type; + } + + @Override + public boolean isCollection() { + return false; + } + + public Mock setType(final EdmType type) { + this.type = type; + return this; + } + + @Override + public String toString() { + return "mock"; + } + + } + + Mock impl = new Mock(); + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + EdmEntityType entityTypeBaseColl = edm.getEntityType(EntityTypeProvider.nameETBaseTwoKeyNav); + edm.getEntityType(EntityTypeProvider.nameETTwoBaseTwoKeyNav); + + impl.setType(entityType); + assertEquals("mock", impl.toString()); + assertEquals("mock", impl.toString(true)); + assertEquals("mock", impl.toString(false)); + + impl.setTypeFilter(entityTypeBaseColl); + assertEquals(entityTypeBaseColl, impl.getTypeFilter()); + assertEquals("mock", impl.toString()); + assertEquals("mock/com.sap.odata.test1.ETBaseTwoKeyNav", impl.toString(true)); + assertEquals("mock", impl.toString(false)); + // + } + + @Test + public void testUriResourceItImpl() { + UriResourceItImpl impl = new UriResourceItImpl(); + assertEquals(UriResourceKind.it, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + assertEquals("$it", impl.toString()); + + impl.setType(entityType); + assertEquals(entityType, impl.getType()); + + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + List<UriParameterImpl> keyPredicates = new ArrayList<UriParameterImpl>(); + keyPredicates.add(parameter); + + assertEquals(false, impl.isCollection()); + impl.setCollection(true); + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(keyPredicates); + assertEquals(false, impl.isCollection()); + } + + @Test + public void testUriResourceNavigationPropertyImpl() { + UriResourceNavigationPropertyImpl impl = new UriResourceNavigationPropertyImpl(); + assertEquals(UriResourceKind.navigationProperty, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + EdmNavigationProperty property = (EdmNavigationProperty) entityType.getProperty("NavPropertyETKeyNavMany"); + assertNotNull(property); + + impl.setNavigationProperty(property); + assertEquals(property, impl.getProperty()); + + assertEquals("NavPropertyETKeyNavMany", impl.toString()); + assertEquals(property.getType(), impl.getType()); + + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + List<UriParameterImpl> keyPredicates = new ArrayList<UriParameterImpl>(); + keyPredicates.add(parameter); + + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(keyPredicates); + assertEquals(false, impl.isCollection()); + } + + @Test + public void testUriResourceRefImpl() { + UriResourceRefImpl impl = new UriResourceRefImpl(); + assertEquals(UriResourceKind.ref, impl.getKind()); + assertEquals("$ref", impl.toString()); + } + + @Test + public void testUriResourceRootImpl() { + UriResourceRootImpl impl = new UriResourceRootImpl(); + assertEquals(UriResourceKind.root, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + assertEquals("$root", impl.toString()); + + impl.setType(entityType); + assertEquals(entityType, impl.getType()); + + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + List<UriParameterImpl> keyPredicates = new ArrayList<UriParameterImpl>(); + keyPredicates.add(parameter); + + assertEquals(false, impl.isCollection()); + impl.setCollection(true); + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(keyPredicates); + assertEquals(false, impl.isCollection()); + } + + @Test + public void testUriResourceSingletonImpl() { + UriResourceSingletonImpl impl = new UriResourceSingletonImpl(); + assertEquals(UriResourceKind.singleton, impl.getKind()); + + EdmSingletonImpl singleton = (EdmSingletonImpl) edm.getEntityContainer(null).getSingleton("SINav"); + EdmEntityType entityTypeBaseColl = edm.getEntityType(EntityTypeProvider.nameETBaseTwoKeyNav); + impl.setSingleton(singleton); + + assertEquals("SINav", impl.toString()); + assertEquals(singleton, impl.getSingleton()); + + assertEquals(singleton.getEntityType(), impl.getType()); + assertEquals(singleton.getEntityType(), impl.getEntityType()); + impl.getEntityType(); + + impl.setTypeFilter(entityTypeBaseColl); + assertEquals(entityTypeBaseColl, impl.getEntityTypeFilter()); + + // is Collection + assertEquals(false, impl.isCollection()); + } + + @Test + public void testUriResourceValueImpl() { + UriResourceValueImpl impl = new UriResourceValueImpl(); + assertEquals(UriResourceKind.value, impl.getKind()); + assertEquals("$value", impl.toString()); + } + + @Test + public void testUriResourceLambdaVarImpl() { + UriResourceLambdaVarImpl impl = new UriResourceLambdaVarImpl(); + assertEquals(UriResourceKind.lambdaVariable, impl.getKind()); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + impl.setType(entityType); + impl.setVariableText("A"); + + assertEquals("A", impl.toString()); + assertEquals(entityType, impl.getType()); + assertEquals("A", impl.getVariableName()); + assertEquals(false, impl.isCollection()); + impl.setCollection(true); + assertEquals(true, impl.isCollection()); + } + + @Test + public void testUriResourceStartingTypeFilterImpl() { + UriResourceStartingTypeFilterImpl impl = new UriResourceStartingTypeFilterImpl(); + + EdmEntityType entityType = edm.getEntityType(EntityTypeProvider.nameETTwoKeyNav); + + impl.setType(entityType); + assertEquals("com.sap.odata.test1.ETTwoKeyNav", impl.toString()); + assertEquals(entityType, impl.getType()); + + UriParameterImpl parameter = new UriParameterImpl().setName("ParameterInt16"); + List<UriParameterImpl> keyPredicates = new ArrayList<UriParameterImpl>(); + keyPredicates.add(parameter); + + assertEquals(false, impl.isCollection()); + impl.setCollection(true); + assertEquals(true, impl.isCollection()); + impl.setKeyPredicates(keyPredicates); + assertEquals(false, impl.isCollection()); + + } +}
