Ejemplo n.º 1
0
        public void HeterogeneousCollectionReaderWithoutMetadataAtomTest()
        {
            IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
            {
                // Collection with different item type kinds (complex instead of primitive)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.PrimitiveCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element>0</m:element>
                                                <m:element>
                                                    <d:bar>2</d:bar>
                                                </m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeKind", "Complex", "Primitive"),
                },

                // Collection where item type kind does not match item type name (primitive and complex items)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element></m:element>
                                                <m:element>
                                                    <d:bar>2</d:bar>
                                                </m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeKind", "Complex", "Primitive"),
                },

                // Collection where item type names don't match (Edm.String and Edm.Int32)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element></m:element>
                                                <m:element m:type='Edm.Int32'>2</m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeName", "Edm.Int32", "Edm.String"),
                },

                // Collection where item type names don't match (Edm.String and Edm.Int32); including some null items
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:null='true' />
                                                <m:element></m:element>
                                                <m:element m:null='true' />
                                                <m:element m:type='Edm.Int32'>2</m:element>
                                                <m:element m:null='true' />
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeName", "Edm.Int32", "Edm.String"),
                },

                // Collection where item type names don't match (TestModel.SomeComplexType and TestModel.OtherComplexType)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:type='TestModel.SomeComplexType'><d:StringProperty>abc</d:StringProperty></m:element>
                                                <m:element m:type='TestModel.OtherComplexType'><d:IntProperty>42</d:IntProperty></m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeName", "TestModel.OtherComplexType", "TestModel.SomeComplexType"),
                },

                // Collection where item type names don't match (TestModel.SomeComplexType and TestModel.OtherComplexType); including some null items
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:null='true' />
                                                <m:element m:type='TestModel.SomeComplexType'><d:StringProperty>abc</d:StringProperty></m:element>
                                                <m:element m:null='true' />
                                                <m:element m:type='TestModel.OtherComplexType'><d:IntProperty>42</d:IntProperty></m:element>
                                                <m:element m:null='true' />
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeName", "TestModel.OtherComplexType", "TestModel.SomeComplexType"),
                },

                // Collection where different item type kinds (primitive instead of complex)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:type='TestModel.SomeComplexType'>
                                                    <d:bar>2</d:bar>
                                                </m:element>
                                                <m:element>0</m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeKind", "Primitive", "Complex"),
                },

                // Collection with primitive and complex elements
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.PrimitiveCollection()
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:type='Edm.String'>Foo</m:element>
                                                <m:element m:type='TestModel.CityType'>
                                                    <d:Name m:type='Edm.String'>Perth</d:Name>
                                                </m:element>
                                            </m:value>"),
                    ExpectedException = ODataExpectedExceptions.ODataException("CollectionWithoutExpectedTypeValidator_IncompatibleItemTypeKind", "Complex", "Primitive"),
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors,
                this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
                (testDescriptor, testConfiguration) =>
            {
                testDescriptor.RunTest(testConfiguration);
            });
        }
Ejemplo n.º 2
0
        public void HeterogeneousCollectionReaderAtomTest()
        {
            EdmModel edmModel = new EdmModel();

            EdmComplexType edmComplexTypeEmpty = new EdmComplexType(ModelNamespace, "EmptyComplexType");

            edmModel.AddElement(edmComplexTypeEmpty);

            EdmComplexType edmComplexTypeCity = new EdmComplexType(ModelNamespace, "CityType");

            edmComplexTypeCity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
            edmModel.AddElement(edmComplexTypeCity);

            EdmComplexType edmComplexTypeAddress = new EdmComplexType(ModelNamespace, "AddressType");

            edmComplexTypeAddress.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(true));
            edmModel.AddElement(edmComplexTypeAddress);

            edmModel.Fixup();

            IEnumerable <PayloadReaderTestDescriptor> testDescriptors = new[]
            {
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = new ComplexInstanceCollection(
                        PayloadBuilder.ComplexValue("TestModel.CityType").Property("Name", PayloadBuilder.PrimitiveValue("Vienna")),
                        PayloadBuilder.ComplexValue("TestModel.AddressType").Property("Street", PayloadBuilder.PrimitiveValue("Am Euro Platz"))
                        ).ExpectedCollectionItemType(edmComplexTypeCity).CollectionName(null),
                    PayloadEdmModel   = edmModel,
                    ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncompatibleType", "TestModel.AddressType", "TestModel.CityType"),
                },

                // primitive collection with primitive and complex elements (with metadata, with expected types)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.PrimitiveCollection()
                                     .ExpectedCollectionItemType(EdmDataTypes.String())
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:type='Edm.String'>Foo</m:element>
                                                <m:element m:type='TestModel.CityType'>
                                                    <d:Name m:type='Edm.String'>Perth</d:Name>
                                                </m:element>
                                             </m:value>"),
                    PayloadEdmModel   = edmModel,
                    ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "TestModel.CityType", "Primitive", "Complex"),
                },

                // complex collection with complex and primitive elements (with metadata, with expected types)
                new PayloadReaderTestDescriptor(this.PayloadTestDescriptorSettings)
                {
                    PayloadElement = PayloadBuilder.ComplexCollection()
                                     .ExpectedCollectionItemType(edmComplexTypeCity)
                                     .XmlRepresentation(@"<m:value>
                                                <m:element m:type='TestModel.CityType'>
                                                    <d:Name m:type='Edm.String'>Perth</d:Name>
                                                </m:element>
                                                <m:element m:type='Edm.Int32'>123</m:element>
                                             </m:value>"),
                    PayloadEdmModel   = edmModel,
                    ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_IncorrectTypeKind", "Edm.Int32", "Complex", "Primitive"),
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                testDescriptors,
                this.ReaderTestConfigurationProvider.AtomFormatConfigurations,
                (testDescriptor, testConfiguration) =>
            {
                testDescriptor.RunTest(testConfiguration);
            });
        }