/// <summary>
        /// Gets the corresponding create reader method name for the given state.
        /// </summary>
        /// <param name="state">State in question.</param>
        /// <returns>Returns the name of the method to create the correct reader for the given state.</returns>
        private static string GetCreateReaderMethodName(ODataParameterReaderState state)
        {
#if SUPPORT_ENTITY_PARAMETER
            Debug.Assert(state == ODataParameterReaderState.Entry || state == ODataParameterReaderState.Feed || state == ODataParameterReaderState.Collection, "state must be Entry, Feed or Collection.");
#else
            Debug.Assert(state == ODataParameterReaderState.Collection, "state must be Collection.");
#endif
            return("Create" + state.ToString() + "Reader");
        }
Exemplo n.º 2
0
 /// <summary>
 /// Gets the corresponding create reader method name for the given state.
 /// </summary>
 /// <param name="state">State in question.</param>
 /// <returns>Returns the name of the method to create the correct reader for the given state.</returns>
 private static string GetCreateReaderMethodName(ODataParameterReaderState state)
 {
     Debug.Assert(state == ODataParameterReaderState.Resource || state == ODataParameterReaderState.ResourceSet || state == ODataParameterReaderState.Collection, "state must be Resource, ResourceSet or Collection.");
     return("Create" + state.ToString() + "Reader");
 }
Exemplo n.º 3
0
        private void RunParameterReaderErrorTest(
            ODataParameterReaderTestWrapper reader,
            ExpectedException expectedException,
            ODataParameterReaderState expectedState = ODataParameterReaderState.Exception)
        {
            if (reader == null)
            {
                // Reader creation failed and we verified the exception already
                return;
            }

            this.Assert.ExpectedException(() => reader.Read(), expectedException, this.ExceptionVerifier);
            this.Assert.AreEqual(expectedState, reader.State, "Reader should be in '" + expectedState.ToString() + "' state.");
        }
Exemplo n.º 4
0
        public void ParameterReaderCreateReaderStateMachineTests()
        {
            IEdmModel           model = TestModels.BuildModelWithFunctionImport();
            IEdmOperationImport functionImport_Primitive           = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_Primitive").First();
            IEdmOperationImport functionImport_PrimitiveCollection = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_PrimitiveCollection").First();
            IEdmOperationImport functionImport_Complex             = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_Complex").First();
            IEdmOperationImport functionImport_ComplexCollection   = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_ComplexCollection").First();
            IEdmOperationImport functionImport_Entry = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_Entry").First();
            IEdmOperationImport functionImport_Feed  = model.FindEntityContainer("TestContainer").FindOperationImports("FunctionImport_Feed").First();

            CreateReaderMethods[] createReaderMethods = new CreateReaderMethods[]
            {
                CreateReaderMethods.CreateCollectionReader,
            };

            var testConfigurations = this.ReaderTestConfigurationProvider.JsonLightFormatConfigurations.Where(c => c.IsRequest);

            this.CombinatorialEngineProvider.RunCombinations(
                testConfigurations,
                createReaderMethods,
                (testConfiguration, createReaderMethod) =>
            {
                // Calling Create*Reader in Start state should fail.
                ODataParameterReader reader = this.CreateParameterReaderForRequestOrResponse(model, functionImport_Complex, testConfiguration, "{ complex : { PrimitiveProperty : \"456\" } }");
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, createReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", createReaderMethod.ToString(), ODataParameterReaderState.Start.ToString()), this.ExceptionVerifier);
                this.Assert.AreEqual(ODataParameterReaderState.Start, reader.State, "Unexpected parameter reader state.");

                // Calling Create*Reader in Value state should fail.
                reader.Read();
                this.Assert.AreEqual(ODataParameterReaderState.Resource, reader.State, "Unexpected parameter reader state.");
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, createReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", createReaderMethod.ToString(), ODataParameterReaderState.Resource.ToString()), this.ExceptionVerifier);
                this.Assert.AreEqual(ODataParameterReaderState.Resource, reader.State, "Unexpected parameter reader state.");

                if (createReaderMethod != CreateReaderMethods.CreateResourceReader)
                {
                    // Calling Create*Reader in Entry state should fail.
                    reader = this.CreateParameterReaderForRequestOrResponse(model, functionImport_Entry, testConfiguration, "{ entry : {} }");
                    reader.Read();
                    this.Assert.AreEqual(ODataParameterReaderState.Resource, reader.State, "Unexpected parameter reader state.");
                    this.Assert.ExpectedException(
                        () => CreateSubReader(reader, createReaderMethod),
                        ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", createReaderMethod.ToString(), ODataParameterReaderState.Resource.ToString()), this.ExceptionVerifier);
                    this.Assert.AreEqual(ODataParameterReaderState.Resource, reader.State, "Unexpected parameter reader state.");
                }

                if (createReaderMethod != CreateReaderMethods.CreateResourceSetReader)
                {
                    // Calling Create*Reader in Feed state should fail.
                    reader = this.CreateParameterReaderForRequestOrResponse(model, functionImport_Feed, testConfiguration, "{ feed : [] }");
                    reader.Read();
                    this.Assert.AreEqual(ODataParameterReaderState.ResourceSet, reader.State, "Unexpected parameter reader state.");
                    this.Assert.ExpectedException(
                        () => CreateSubReader(reader, createReaderMethod),
                        ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", createReaderMethod.ToString(), ODataParameterReaderState.ResourceSet.ToString()), this.ExceptionVerifier);
                    this.Assert.AreEqual(ODataParameterReaderState.ResourceSet, reader.State, "Unexpected parameter reader state.");
                }

                if (createReaderMethod != CreateReaderMethods.CreateCollectionReader)
                {
                    // Calling Create*Reader in Collection state should fail.
                    reader = this.CreateParameterReaderForRequestOrResponse(model, functionImport_ComplexCollection, testConfiguration, "{ complexCollection : [] }");
                    reader.Read();
                    this.Assert.AreEqual(ODataParameterReaderState.Collection, reader.State, "Unexpected parameter reader state.");
                    this.Assert.ExpectedException(
                        () => CreateSubReader(reader, createReaderMethod),
                        ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", createReaderMethod.ToString(), ODataParameterReaderState.Collection.ToString()), this.ExceptionVerifier);
                    this.Assert.AreEqual(ODataParameterReaderState.Collection, reader.State, "Unexpected parameter reader state.");
                }

                // Calling Read() in Entry/Feed/Collection state without calling Create***Reader should fail.
                IEdmOperationImport functionImport = createReaderMethod == CreateReaderMethods.CreateResourceReader ? functionImport_Entry : (createReaderMethod == CreateReaderMethods.CreateResourceSetReader ? functionImport_Feed : functionImport_ComplexCollection);
                string payload = createReaderMethod == CreateReaderMethods.CreateResourceReader ? "{ entry : {} }" : (createReaderMethod == CreateReaderMethods.CreateResourceSetReader ? "{ feed : [] }" : "{ complexCollection : [] }");
                ODataParameterReaderState expectedParameterState = createReaderMethod == CreateReaderMethods.CreateResourceReader ? ODataParameterReaderState.Resource : ODataParameterReaderState.ResourceSet;
                var expectedReaderMethod = createReaderMethod == CreateReaderMethods.CreateCollectionReader ? CreateReaderMethods.CreateResourceSetReader.ToString() : createReaderMethod.ToString();
                reader = this.CreateParameterReaderForRequestOrResponse(model, functionImport, testConfiguration, payload);
                reader.Read();
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");
                this.Assert.ExpectedException(
                    () => reader.Read(),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_SubReaderMustBeCreatedAndReadToCompletionBeforeTheNextReadOrReadAsyncCall", expectedParameterState.ToString(), expectedReaderMethod), this.ExceptionVerifier);
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");

                // Calling Read() in Entry/Feed/Collection state after Create***Reader() is called but before the created reader finishes should fail.
                var subReaderMethod = createReaderMethod == CreateReaderMethods.CreateCollectionReader
                        ? CreateReaderMethods.CreateResourceSetReader : createReaderMethod;
                object subReader = CreateSubReader(reader,
                                                   subReaderMethod);
                this.Assert.ExpectedException(
                    () => reader.Read(),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_SubReaderMustBeInCompletedStateBeforeTheNextReadOrReadAsyncCall", expectedParameterState.ToString(), expectedReaderMethod), this.ExceptionVerifier);
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");

                // Calling Create*Reader() before the sub-reader is completed should fail.
                string parameterName = createReaderMethod == CreateReaderMethods.CreateResourceReader ? "entry" : (createReaderMethod == CreateReaderMethods.CreateResourceSetReader ? "feed" : "complexCollection");
                subReader.GetType().GetMethod("Read").Invoke(subReader, null);
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, subReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_CreateReaderAlreadyCalled", expectedReaderMethod, parameterName), this.ExceptionVerifier);
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");

                // Calling Create*Reader() after sub-reader is completed should fail.
                while ((bool)subReader.GetType().GetMethod("Read").Invoke(subReader, null))
                {
                    ;
                }
                this.Assert.AreEqual("Completed", subReader.GetType().GetProperty("State").GetValue(subReader, null).ToString(), "Unexpected sub-reader state.");
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, subReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_CreateReaderAlreadyCalled", expectedReaderMethod, parameterName), this.ExceptionVerifier);
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");

                // Finish reading...
                reader.Read();
                this.Assert.AreEqual(ODataParameterReaderState.Completed, reader.State, "Unexpected parameter reader state.");

                // Calling Create*Reader in Completed state should fail.
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, subReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", expectedReaderMethod, ODataParameterReaderState.Completed.ToString()), this.ExceptionVerifier);
                this.Assert.AreEqual(ODataParameterReaderState.Completed, reader.State, "Unexpected parameter reader state.");

                // Exception in subReader should put parent reader in Exception state.
                payload = createReaderMethod == CreateReaderMethods.CreateResourceReader ? "{ entry : \"foo\" }" : (createReaderMethod == CreateReaderMethods.CreateResourceSetReader ? "{ feed : { \"foo\" : \"bar\" } }" : "{ complexCollection : { \"foo\" : \"bar\" } }");
                reader  = this.CreateParameterReaderForRequestOrResponse(model, functionImport, testConfiguration, payload);
                reader.Read();
                this.Assert.AreEqual(expectedParameterState, reader.State, "Unexpected parameter reader state.");
                subReader = CreateSubReader(reader, subReaderMethod);
                this.Assert.IsNotNull(TestExceptionUtils.RunCatching(() => { while ((bool)subReader.GetType().GetMethod("Read").Invoke(subReader, null))
                                                                             {
                                                                             }
                                                                     }), "Expecting sub-reader.Read() to fail.");
                this.Assert.AreEqual("Exception", subReader.GetType().GetProperty("State").GetValue(subReader, null).ToString(), "Unexpected sub-reader state.");
                this.Assert.AreEqual(ODataParameterReaderState.Exception, reader.State, "Unexpected parameter reader state.");

                // Calling Create*Reader in Exception state should fail.
                this.Assert.ExpectedException(
                    () => CreateSubReader(reader, subReaderMethod),
                    ODataExpectedExceptions.ODataException("ODataParameterReaderCore_InvalidCreateReaderMethodCalledForState", expectedReaderMethod, ODataParameterReaderState.Exception.ToString()), this.ExceptionVerifier);
                this.Assert.AreEqual(ODataParameterReaderState.Exception, reader.State, "Unexpected parameter reader state.");
            });
        }
Exemplo n.º 5
0
        private void RunParameterReaderErrorTest(
            ODataParameterReaderTestWrapper reader,
            ExpectedException expectedException,
            ODataParameterReaderState expectedState = ODataParameterReaderState.Exception)
        {
            if (reader == null)
            {
                // Reader creation failed and we verified the exception already
                return;
            }

            this.Assert.ExpectedException(() => reader.Read(), expectedException, this.ExceptionVerifier);
            this.Assert.AreEqual(expectedState, reader.State, "Reader should be in '" + expectedState.ToString() + "' state.");
        }
Exemplo n.º 6
0
 private static string GetCreateReaderMethodName(ODataParameterReaderState state)
 {
     return("Create" + state.ToString() + "Reader");
 }
Exemplo n.º 7
0
 /// <summary>
 /// Gets the corresponding create reader method name for the given state.
 /// </summary>
 /// <param name="state">State in question.</param>
 /// <returns>Returns the name of the method to create the correct reader for the given state.</returns>
 private static string GetCreateReaderMethodName(ODataParameterReaderState state)
 {
     Debug.Assert(state == ODataParameterReaderState.Entry || state == ODataParameterReaderState.Feed || state == ODataParameterReaderState.Collection, "state must be Entry, Feed or Collection.");
     return("Create" + state.ToString() + "Reader");
 }