Beispiel #1
0
 /// <summary>
 /// Creates a set of interesting collections test descriptors along with metadata.
 /// </summary>
 /// <param name="withTypeNames">true if the complex value payloads should specify type names.</param>
 /// <param name="fullSet">true if all available collections should be returned, false if only the most interesting subset should be returned.</param>
 /// <returns>List of interesting test descriptors.</returns>
 internal static IEnumerable <PayloadReaderTestDescriptor> CreateCollectionTestDescriptors(
     PayloadReaderTestDescriptor.Settings settings,
     bool withTypeNames,
     bool fullSet = true)
 {
     return(CreatePrimitiveCollectionTestDescriptors(settings, withTypeNames, fullSet)
            .Concat(CreateComplexCollectionTestDescriptors(settings, withTypeNames, fullSet)));
 }
Beispiel #2
0
        /// <summary>
        /// Creates a set of interesting primitive value test descriptors along with metadata.
        /// </summary>
        /// <param name="settings">The settings for payload reader test descriptor to use.</param>
        /// <param name="fullSet">true if all available primitive values should be returned, false if only the most interesting subset should be returned.</param>
        /// <returns>List of interesting test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreatePrimitiveValueTestDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            bool fullSet = true)
        {
            EdmModel model = new EdmModel().Fixup();
            IEnumerable <PrimitiveValue> primitiveValues = TestValues.CreatePrimitiveValuesWithMetadata(fullSet);

            return(primitiveValues.Select(c => new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = c, PayloadEdmModel = model
            }));
        }
Beispiel #3
0
        /// <summary>
        /// Creates a set of interesting deferred navigation link test descriptors along with metadata.
        /// </summary>
        /// <param name="settings">The settings for payload reader test descriptor to use.</param>
        /// <param name="withMetadata">true if the generated test descriptors should have metadata.</param>
        /// <returns>Enumeration of interesting test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateDeferredNavigationLinkTestDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            bool withMetadata)
        {
            EdmModel model = withMetadata ? new EdmModel().Fixup() : null;

            return(TestValues.CreateDeferredNavigationLinks().Select(navigationLink =>
                                                                     new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = navigationLink,
                PayloadEdmModel = model
            }));
        }
Beispiel #4
0
        /// <summary>
        /// Creates a set of interesting complex value test descriptors along with metadata.
        /// </summary>
        /// <param name="settings">The settings for payload reader test descriptor to use.</param>
        /// <param name="withTypeNames">true if the complex value payloads should specify type names.</param>
        /// <param name="withMetadata">true if the generated test descriptors should have metadata.</param>
        /// <param name="fullSet">true if all available complex values should be returned, false if only the most interesting subset should be returned.</param>
        /// <returns>List of interesting test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateComplexValueTestDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            bool withTypeNames,
            bool fullSet = true)
        {
            EdmModel model = new EdmModel().Fixup();
            IEnumerable <ComplexInstance> complexValues = TestValues.CreateComplexValues(model, withTypeNames, fullSet);

            return(complexValues.Select(c => new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = c, PayloadEdmModel = model
            }));
        }
Beispiel #5
0
        /// <summary>
        /// Creates a set of interesting collections with complex items test descriptors along with metadata.
        /// </summary>
        /// <param name="withTypeNames">true if the complex value payloads should specify type names.</param>
        /// <param name="fullSet">true if all available complex collections should be returned, false if only the most interesting subset should be returned.</param>
        /// <returns>List of interesting test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateComplexCollectionTestDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            bool withTypeNames,
            bool fullSet = true)
        {
            EdmModel model = new EdmModel().Fixup();
            IEnumerable <ComplexMultiValue> complexCollections = TestValues.CreateComplexCollections(model, withTypeNames, fullSet);

            return(complexCollections.Select(collection =>
                                             new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = collection,
                PayloadEdmModel = model,
                SkipTestConfiguration = tc => tc.Version < ODataVersion.V4,
            }));
        }
Beispiel #6
0
        /// <summary>
        /// Creates a set of interesting entity set instances along with metadata.
        /// </summary>
        /// <param name="settings">The test descriptor settings to use.</param>
        /// <param name="model">If non-null, the method creates types as needed and adds them to the model.</param>
        /// <param name="withTypeNames">true if the payloads should specify type names.</param>
        /// <returns>List of test descriptors with interesting entity instances as payload.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateEntitySetInstanceDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            EdmModel model,
            bool withTypeNames)
        {
            List <PayloadReaderTestDescriptor> testDescriptors = new List <PayloadReaderTestDescriptor>();

            foreach (var payloadDescriptor in TestFeeds.CreateEntitySetTestDescriptors(model, withTypeNames))
            {
                testDescriptors.Add(new PayloadReaderTestDescriptor(settings)
                {
                    PayloadDescriptor     = payloadDescriptor,
                    PayloadEdmModel       = payloadDescriptor.PayloadEdmModel,
                    SkipTestConfiguration = tc => payloadDescriptor.SkipTestConfiguration == null ? false : payloadDescriptor.SkipTestConfiguration(tc)
                });
            }
            return(testDescriptors);
        }
Beispiel #7
0
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateEntityInstanceDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            EdmModel model,
            bool withTypeNames)
        {
            List <PayloadReaderTestDescriptor> testDescriptors = new List <PayloadReaderTestDescriptor>();

            foreach (var payloadDescriptor in TestEntityInstances.CreateEntityInstanceTestDescriptors(model, withTypeNames))
            {
                // NOTE so far we don't have version-specific entity instances so we don't have to specify a
                //      minimum version or skip function; once we do we'll have to change that
                PayloadReaderTestDescriptor testDescriptor = new PayloadReaderTestDescriptor(settings)
                {
                    PayloadDescriptor = payloadDescriptor
                };
                testDescriptors.Add(testDescriptor);
            }
            return(testDescriptors);
        }
Beispiel #8
0
        /// <summary>
        /// Creates a set of interesting homogeneous collection value test descriptors along with metadata.
        /// </summary>
        /// <param name="settings">The settings for the payload reader test descriptor to use.</param>
        /// <param name="withMetadata">true if the generated test descriptors should have metadata.</param>
        /// <param name="withTypeNames">true if the collection value payloads should specify type names.</param>
        /// <param name="withExpectedType">true if an expected type annotation should be added to the generated payload element; otherwise false.</param>
        /// <param name="withcollectionName">true if the collection is not in the top level, otherwise false</param>
        /// <param name="fullSet">true if all available collection values should be returned, false if only the most interesting subset should be returned.</param>
        /// <returns>List of interesting test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateHomogeneousCollectionValueTestDescriptors(
            PayloadReaderTestDescriptor.Settings settings,
            bool withMetadata,
            bool withTypeNames,
            bool withExpectedType,
            bool withcollectionName,
            bool fullSet = true)
        {
            EdmModel model = withMetadata ? new EdmModel() : null;
            IEnumerable <ODataPayloadElementCollection> collectionValues = TestValues.CreateHomogeneousCollectionValues(model, withTypeNames, withExpectedType, withcollectionName, fullSet);

            return(collectionValues.Select(collectionValue =>
            {
                PayloadReaderTestDescriptor testDescriptor = new PayloadReaderTestDescriptor(settings)
                {
                    PayloadElement = collectionValue,
                    PayloadEdmModel = model
                };

                if (withExpectedType && !withTypeNames)
                {
                    // fill in the type names for the expected result payload since they will be added based on the expected type
                    testDescriptor.ExpectedResultNormalizers.Add(tc => FillTypeNamesFromTypeAnnotationsPayloadElementVisitor.Visit);
                }

                if (!withExpectedType)
                {
                    testDescriptor.ExpectedResultNormalizers.Add(
                        tc => (Func <ODataPayloadElement, ODataPayloadElement>)null);
                }

                // Do not run the test descriptor if we do not have an expected type in JSON Light because it would fail.
                testDescriptor.SkipTestConfiguration = tc => tc.Format == ODataFormat.Json && !withExpectedType;

                return testDescriptor;
            }));
        }
Beispiel #9
0
 /// <summary>
 /// Creates a set of interesting expanded navigation link test descriptors along with metadata.
 /// </summary>
 /// <param name="settings">The settings for payload reader test descriptor to use.</param>
 /// <param name="withMetadata">true if the generated test descriptors should have metadata.</param>
 /// <returns>Enumeration of interesting test descriptors.</returns>
 internal static IEnumerable <PayloadReaderTestDescriptor> CreateExpandedNavigationLinkTestDescriptors(
     PayloadReaderTestDescriptor.Settings settings,
     bool withMetadata)
 {
     return((IEnumerable <PayloadReaderTestDescriptor>)CreateDeferredNavigationLinkTestDescriptors(settings, withMetadata).SelectMany(td => new[]
     {
         new PayloadReaderTestDescriptor(settings)
         {
             PayloadDescriptor = td.PayloadDescriptor.ExpandNavigationProperty(true)
         },
         new PayloadReaderTestDescriptor(settings)
         {
             PayloadDescriptor = td.PayloadDescriptor.ExpandNavigationProperty(false)
         },
         new PayloadReaderTestDescriptor(settings)
         {
             PayloadDescriptor = td.PayloadDescriptor.ExpandNavigationProperty(false, 5)
         },
         new PayloadReaderTestDescriptor(settings)
         {
             PayloadDescriptor = td.PayloadDescriptor.ExpandNavigationProperty(false, 5, "http://odata.org/expanded_navigation_link_next_feed_link")
         }
     }));
 }
Beispiel #10
0
        /// <summary>
        /// Creates a set of interesting service document instances.
        /// </summary>
        /// <param name="settings">The test descriptor settings to use.</param>
        /// <param name="withTitles">true if workspaces and collections should have a title; otherwise false.</param>
        /// <returns>List of test descriptors with interesting service documents as payload.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateServiceDocumentDescriptors(PayloadReaderTestDescriptor.Settings settings, string baseUri, bool withTitles)
        {
            return(TestServiceDocuments.CreateServiceDocuments(withTitles, baseUri).Select(sd =>
            {
                PayloadReaderTestDescriptor testDescriptor = new PayloadReaderTestDescriptor(settings)
                {
                    PayloadElement = sd,
                    SkipTestConfiguration = tc => tc.IsRequest         // service docs are only allowed in responses
                };

                return testDescriptor;
            }));
        }
Beispiel #11
0
        /// <summary>
        /// Creates a set of interesting stream reference (named stream) test descriptors, optionally with metadata.
        /// </summary>
        /// <param name="settings">The settings for payload reader test descriptor to use.</param>
        /// <param name="withMetadata">true if the generated test descriptors should have metadata.</param>
        /// <returns>Enumeration of interesting stream reference test descriptors.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateStreamReferenceValueTestDescriptors(PayloadReaderTestDescriptor.Settings settings, bool withMetadata)
        {
            EdmModel model = withMetadata ? new EdmModel().Fixup() : null;
            IEnumerable <NamedStreamInstance> namedStreams = TestValues.CreateStreamReferenceValues();

            return(namedStreams.Select(c => new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = c, PayloadEdmModel = model
            }));
        }
Beispiel #12
0
        /// <summary>
        /// Returns the serialized batch payload
        /// </summary>
        /// <param name="batchPayload">batch payload</param>
        /// <returns>bytes representing batch payload</returns>
        private static byte[] SerializeBatchPayload(ODataPayloadElement batchPayload, PayloadReaderTestDescriptor.Settings settings)
        {
            string boundary = null;

            Byte[] bytes = null;

            Func <ODataPayloadElement, string> getBoundaryAnnotation = (batchPayloadElement) =>
            {
                var boundaryAnn = batchPayloadElement.Annotations.OfType <BatchBoundaryAnnotation>().Single();
                ExceptionUtilities.CheckObjectNotNull(boundaryAnn, "bounday annotation cannot be null");
                return(boundaryAnn.BatchBoundaryInPayload);
            };

            var batchRequestPayload = batchPayload as BatchRequestPayload;

            if (batchRequestPayload != null)
            {
                boundary = getBoundaryAnnotation(batchRequestPayload);
                bytes    = settings.BatchSerializer.SerializeBatchPayload(batchRequestPayload, boundary, Encoding.UTF8.WebName); // encoding assumed to be UTF8
            }
            else
            {
                var batchResponsePayload = batchPayload as BatchResponsePayload;
                boundary = getBoundaryAnnotation(batchResponsePayload);
                ExceptionUtilities.CheckObjectNotNull(batchResponsePayload, "the specified batch payload is neither a request payload nor a response");
                bytes = settings.BatchSerializer.SerializeBatchPayload(batchResponsePayload, boundary, Encoding.UTF8.WebName); // encoding assumed to be UTF8
            }

            return(bytes);
        }
 /// <summary>
 /// Creates a set of interesting entity reference links (collection) instances.
 /// </summary>
 /// <param name="settings">The test descriptor settings to use.</param>
 /// <returns>List of test descriptors with interesting entity reference links instances as payload.</returns>
 internal static IEnumerable <PayloadReaderTestDescriptor> CreateEntityReferenceLinksDescriptors(PayloadReaderTestDescriptor.Settings settings)
 {
     return(CreateEntityReferenceLinksValues().Select(erl =>
                                                      new PayloadReaderTestDescriptor(settings)
     {
         PayloadElement = erl,
         SkipTestConfiguration = c => (c.IsRequest) && (erl.NextLink != null || erl.InlineCount.HasValue),
         ExpectedResultCallback = tc =>
                                  new PayloadReaderTestExpectedResult(settings.ExpectedResultSettings)
     }));
 }
 /// <summary>
 /// Creates a set of interesting entity reference link instances.
 /// </summary>
 /// <param name="settings">The test descriptor settings to use.</param>
 /// <returns>List of test descriptors with interesting entity reference link instances as payload.</returns>
 internal static IEnumerable <PayloadReaderTestDescriptor> CreateEntityReferenceLinkDescriptors(PayloadReaderTestDescriptor.Settings settings)
 {
     return(CreateEntityReferenceLinkValues().Select(erl =>
                                                     new PayloadReaderTestDescriptor(settings)
     {
         PayloadElement = erl,
     }));
 }
Beispiel #15
0
        /// <summary>
        /// Creates the input message for the test descriptor
        /// </summary>
        /// <param name="testConfiguration">the test configuration to use</param>
        /// <param name="readerTestDescriptor">The test descriptor</param>
        /// <param name="settings">The test descriptor settings</param>
        /// <param name="applyPayloadTransformations">Whether or not to apply payload transformations</param>
        /// <returns>The message for the test</returns>
        public static TestMessage CreateInputMessage(ReaderTestConfiguration testConfiguration,
                                                     PayloadReaderTestDescriptor readerTestDescriptor,
                                                     PayloadReaderTestDescriptor.Settings settings,
                                                     bool?applyPayloadTransformations)
        {
            TestMessage testMessage;
            bool        originalApplyTransformValue = false;
            var         odataTransformFactory       = settings.PayloadTransformFactory as ODataLibPayloadTransformFactory;

            try
            {
                if (applyPayloadTransformations.HasValue && odataTransformFactory != null)
                {
                    originalApplyTransformValue          = odataTransformFactory.ApplyTransform;
                    odataTransformFactory.ApplyTransform = applyPayloadTransformations.Value;
                }

                if (readerTestDescriptor.TestDescriptorNormalizers != null)
                {
                    foreach (var testDescriptorNormalizer in readerTestDescriptor.TestDescriptorNormalizers)
                    {
                        var normalizerAction = testDescriptorNormalizer(testConfiguration);
                        if (normalizerAction != null)
                        {
                            normalizerAction(readerTestDescriptor);
                        }
                    }
                }

                MemoryStream memoryStream  = new MemoryStream(GetPayload(testConfiguration, readerTestDescriptor.PayloadNormalizers, settings, readerTestDescriptor.PayloadElement));
                TestStream   messageStream = new TestStream(memoryStream);
                if (testConfiguration.Synchronous)
                {
                    messageStream.FailAsynchronousCalls = true;
                }
                else
                {
                    messageStream.FailSynchronousCalls = true;
                }

                testMessage = TestReaderUtils.CreateInputMessageFromStream(
                    messageStream,
                    testConfiguration,
                    readerTestDescriptor.PayloadElement.GetPayloadKindFromPayloadElement(),
                    readerTestDescriptor.PayloadElement.GetCustomContentTypeHeader(), readerTestDescriptor.UrlResolver);

                if (readerTestDescriptor.TestMessageWrapper != null)
                {
                    testMessage = readerTestDescriptor.TestMessageWrapper(testMessage);
                }

                return(testMessage);
            }
            finally
            {
                if (applyPayloadTransformations.HasValue && odataTransformFactory != null)
                {
                    odataTransformFactory.ApplyTransform = originalApplyTransformValue;
                }
            }
        }
Beispiel #16
0
 /// <summary>
 /// Creates a set of test descriptors with interesting error payloads.
 /// </summary>
 /// <param name="settings">The test descriptor settings to use.</param>
 /// <returns>List of test descriptors with interesting errors as payload.</returns>
 internal static IEnumerable <PayloadReaderTestDescriptor> CreateErrorReaderTestDescriptors(PayloadReaderTestDescriptor.Settings settings)
 {
     return(TestErrors.CreateErrorTestDescriptors().Select(err =>
                                                           new PayloadReaderTestDescriptor(settings)
     {
         PayloadElement = err.PayloadElement,
         SkipTestConfiguration = tc => tc.IsRequest
     }));
 }
Beispiel #17
0
        /// <summary>
        /// Creates error reader test descriptors with deeply nested internal exceptions.
        /// </summary>
        /// <param name="settings">The test descriptor settings to use.</param>
        /// <param name="depthLimit">The maximum depth limit for nested errors. Payloads with error depth over this limit should fail.</param>
        /// <returns>An enumerable of <see cref="PayloadReaderTestDescriptor"/> representing the deeply nested error payloads.</returns>
        internal static IEnumerable <PayloadReaderTestDescriptor> CreateErrorDeeplyNestedReaderTestDescriptors(PayloadReaderTestDescriptor.Settings settings, int depthLimit)
        {
            ODataInternalExceptionPayload deeplyNestedInnerError = PayloadBuilder.InnerError();

            // Create 'depthLimit' levels of depth (loop 'depthLimit - 1' times since we've already constructed one inner error).
            for (int index = 0; index < depthLimit - 1; index++)
            {
                deeplyNestedInnerError.InnerError(deeplyNestedInnerError.DeepCopy());
            }

            // Add one more level of depth to create an invalid payload.
            ODataInternalExceptionPayload tooDeeplyNestedInnerError = PayloadBuilder.InnerError().InnerError(deeplyNestedInnerError.DeepCopy());

            yield return(new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = PayloadBuilder.Error().InnerError(deeplyNestedInnerError),
                SkipTestConfiguration = tc => tc.IsRequest
            });

            yield return(new PayloadReaderTestDescriptor(settings)
            {
                PayloadElement = PayloadBuilder.Error().InnerError(tooDeeplyNestedInnerError),
                ExpectedException = ODataExpectedExceptions.ODataException("ValidationUtils_RecursionDepthLimitReached", Convert.ToString(depthLimit)),
                SkipTestConfiguration = tc => tc.IsRequest
            });
        }
Beispiel #18
0
        /// <summary>
        /// Returns the payload to be used for this test case and the specified test configuration.
        /// </summary>
        /// <param name="testConfiguration">The test configuration to use.</param>
        /// <returns>The payload to use for testing.</returns>
        public static byte[] GetPayload(
            ReaderTestConfiguration testConfiguration,
            List <Func <ReaderTestConfiguration, Func <ODataPayloadElement, ODataPayloadElement> > > payloadNormalizers,
            PayloadReaderTestDescriptor.Settings settings,
            ODataPayloadElement payloadElement)
        {
            IPayloadSerializer payloadSerializer = null;

            // Apply all payload element transforms before serialization.
            IPayloadTransform <ODataPayloadElement> payloadElementTransform = settings.PayloadTransformFactory.GetTransform <ODataPayloadElement>();
            ODataPayloadElement transformedODataElement = null;

            if (payloadElementTransform.TryTransform(payloadElement, out transformedODataElement))
            {
                payloadElement = transformedODataElement;
            }

            ODataPayloadElement payloadElementToSerialize = payloadElement;

            // Apply all normalizers/fixups before serialization
            if (payloadNormalizers != null)
            {
                ODataPayloadElement payloadElementCopy = null;
                foreach (var getPayloadNormalizerFunc in payloadNormalizers)
                {
                    var normalizer = getPayloadNormalizerFunc(testConfiguration);
                    if (normalizer != null)
                    {
                        if (payloadElementCopy == null)
                        {
                            payloadElementCopy = payloadElementToSerialize.DeepCopy();
                        }

                        payloadElementCopy = normalizer(payloadElementCopy);
                    }
                }

                payloadElementToSerialize = payloadElementCopy ?? payloadElementToSerialize;
            }

            if (testConfiguration.Format == ODataFormat.Atom)
            {
                payloadSerializer = new XmlPayloadSerializer(settings.PayloadElementToXmlConverter);
            }
            else if (testConfiguration.Format == ODataFormat.Json)
            {
                // Create a copy of the payload element so that we can add annotations to it.
                payloadElementToSerialize = payloadElementToSerialize.DeepCopy();

                // Annotate elements with version and response/request as appropriate
                PayloadFormatVersionAnnotatingVisitor.AnnotateJsonLight(
                    payloadElementToSerialize,
                    testConfiguration.Version.ToDataServiceProtocolVersion(),
                    testConfiguration.IsRequest);

                payloadSerializer = new JsonPayloadSerializer(settings.PayloadElementToJsonLightConverter.ConvertToJsonLight);
            }
            else if (testConfiguration.Format == null)
            {
                if (payloadElementToSerialize.ElementType == ODataPayloadElementType.PrimitiveValue)
                {
                    PrimitiveValue primitiveValue = (PrimitiveValue)payloadElementToSerialize;
                    if (primitiveValue.ClrValue == null)
                    {
                        throw new NotSupportedException("Reading null values is not supported (since we don't support writing null values).");
                    }
                    else if (primitiveValue.ClrValue.GetType() == typeof(byte[]))
                    {
                        payloadSerializer = settings.BinaryValuePayloadElementConverter;
                    }
                    else
                    {
                        payloadSerializer = settings.TextValuePayloadElementConverter;
                    }
                }
                else if (payloadElementToSerialize.ElementType == ODataPayloadElementType.BatchRequestPayload || payloadElementToSerialize.ElementType == ODataPayloadElementType.BatchResponsePayload)
                {
                    return(SerializeBatchPayload(payloadElementToSerialize, settings));
                }
                else
                {
                    throw new NotImplementedException("Default format not yet implemented for payload test descriptor and payload element type '" + payloadElementToSerialize.ElementType + "'.");
                }
            }
            else
            {
                throw new NotSupportedException("Unexpected format.");
            }

            // Default encoding is UTF8
            return(payloadSerializer.SerializeToBinary(payloadElementToSerialize, null));
        }