/// <summary> /// Gets the value of an enumeration option. /// </summary> /// <param name="enumerationType">The type of the enumeration.</param> /// <param name="value">The value to get from the enumeration.</param> /// <returns>The value of the option on the enumeration.</returns> public static object GetEnumerationValue(Type enumerationType, string value) { ExceptionUtilities.CheckArgumentNotNull(enumerationType, "enumerationType"); ExceptionUtilities.CheckStringArgumentIsNotNullOrEmpty(value, "value"); foreach (var enumValue in EnumExtensionMethods.GetValues(enumerationType)) { if (enumValue.ToString() == value) { return(enumValue); } } throw new ArgumentException(String.Format("Failed to find value '{0}' in enum type '{1}", value, enumerationType.Name)); }
public void CollectionWriterStatesTest() { var testCases = new CollectionWriterStatesTestDescriptor[] { new CollectionWriterStatesTestDescriptor { DebugDescription = "Start", Setup = null, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, null }, { CollectionWriterAction.Item, "Cannot transition from state 'Start' to state 'Item'. The only valid actions in state 'Start' are to write the collection or to write nothing at all." }, { CollectionWriterAction.End, "ODataCollectionWriter.WriteEnd was called in an invalid state ('Start'); WriteEnd is only supported in states 'Start', 'Collection', and 'Item'." }, { CollectionWriterAction.Error, null }, } }, new CollectionWriterStatesTestDescriptor { DebugDescription = "Collection", Setup = (mw, w, s) => { w.WriteStart(new ODataCollectionStart { Name = "foo" }); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Collection' to state 'Collection'. The only valid actions in state 'Collection' are to write an item or to write the end of the collection." }, { CollectionWriterAction.Item, null }, { CollectionWriterAction.End, null }, { CollectionWriterAction.Error, null }, } }, new CollectionWriterStatesTestDescriptor { DebugDescription = "Item", Setup = (mw, w, s) => { w.WriteStart(new ODataCollectionStart { Name = "foo" }); w.WriteItem(42); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Item' to state 'Collection'. The only valid actions in state 'Item' are to write an item or the end of the collection." }, { CollectionWriterAction.Item, null }, { CollectionWriterAction.End, null }, { CollectionWriterAction.Error, null }, } }, new CollectionWriterStatesTestDescriptor { DebugDescription = "Completed", Setup = (mw, w, s) => { w.WriteStart(new ODataCollectionStart { Name = "foo" }); w.WriteEnd(); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Completed' to state 'Collection'. Nothing further can be written once the writer has completed." }, { CollectionWriterAction.Item, "Cannot transition from state 'Completed' to state 'Item'. Nothing further can be written once the writer has completed." }, { CollectionWriterAction.End, "ODataCollectionWriter.WriteEnd was called in an invalid state ('Completed'); WriteEnd is only supported in states 'Start', 'Collection', and 'Item'." }, { CollectionWriterAction.Error, "Cannot transition from state 'Completed' to state 'Error'. Nothing further can be written once the writer has completed." }, } }, new CollectionWriterStatesTestDescriptor { DebugDescription = "ODataExceptionThrown", Setup = (mw, w, s) => { TestExceptionUtils.RunCatching(() => w.WriteItem(42)); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Error' to state 'Collection'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.Item, "Cannot transition from state 'Error' to state 'Item'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.End, "ODataCollectionWriter.WriteEnd was called in an invalid state ('Error'); WriteEnd is only supported in states 'Start', 'Collection', and 'Item'." }, { CollectionWriterAction.Error, null }, } }, new CollectionWriterStatesTestDescriptor { DebugDescription = "FatalExceptionThrown", Setup = (mw, w, s) => { // In JSON we can make the stream fail s.FailNextCall = true; w.WriteStart(new ODataCollectionStart { Name = "foo" }); TestExceptionUtils.RunCatching(() => w.Flush()); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Error' to state 'Collection'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.Item, "Cannot transition from state 'Error' to state 'Item'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.End, "ODataCollectionWriter.WriteEnd was called in an invalid state ('Error'); WriteEnd is only supported in states 'Start', 'Collection', and 'Item'." }, { CollectionWriterAction.Error, null }, }, // There's no simple way to make the writer go into a fatal exception state with XmlWriter underneath. // XmlWriter will move to an Error state if anything goes wrong with it, and thus we can't write into it anymore. // As a result for example the in-stream error case for this one can't work as it should. SkipForConfiguration = (tc) => tc.Format != ODataFormat.Json }, new CollectionWriterStatesTestDescriptor { DebugDescription = "Error", Setup = (mw, w, s) => { mw.WriteError(new ODataError(), false); }, ExpectedResults = new Dictionary <CollectionWriterAction, string> { { CollectionWriterAction.Start, "Cannot transition from state 'Error' to state 'Collection'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.Item, "Cannot transition from state 'Error' to state 'Item'. Nothing can be written once the writer entered the error state." }, { CollectionWriterAction.End, "ODataCollectionWriter.WriteEnd was called in an invalid state ('Error'); WriteEnd is only supported in states 'Start', 'Collection', and 'Item'." }, { CollectionWriterAction.Error, "The WriteError method or the WriteErrorAsync method on the ODataMessageWriter has already been called to write an error payload. Only a single error payload can be written with each ODataMessageWriter instance." }, } }, }; //ToDo: Fix places where we've lost JsonVerbose coverage to add JsonLight this.CombinatorialEngineProvider.RunCombinations( testCases, EnumExtensionMethods.GetValues <CollectionWriterAction>().Cast <CollectionWriterAction>(), this.WriterTestConfigurationProvider.ExplicitFormatConfigurations.Where(tc => false), (testCase, writerAction, testConfiguration) => { using (TestStream stream = new TestStream()) { if (testCase.SkipForConfiguration != null && testCase.SkipForConfiguration(testConfiguration)) { return; } // We purposely don't use the using pattern around the messageWriter here. Disposing the message writer will // fail here because the writer is not left in a valid state. var messageWriter = TestWriterUtils.CreateMessageWriter(stream, testConfiguration, this.Assert); ODataCollectionWriter writer = messageWriter.CreateODataCollectionWriter(); if (testCase.Setup != null) { testCase.Setup(messageWriter, writer, stream); } string expectedException = testCase.ExpectedResults[writerAction]; this.Assert.ExpectedException <ODataException>( () => InvokeCollectionWriterAction(messageWriter, writer, writerAction), expectedException); } }); }
public void BatchWriterStatesTest() { var testCases = new BatchWriterStatesTestDescriptor[] { // Start new BatchWriterStatesTestDescriptor { Setup = null, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, null }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromStart") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromStart") }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromStart") }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // BatchStarted new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); return(null); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromBatchStarted") }, { BatchWriterAction.EndBatch, null }, { BatchWriterAction.StartChangeset, null }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // ChangeSetStarted new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteStartChangeset(); return(null); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromChangeSetStarted") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteBatchWithActiveChangeSet") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotStartChangeSetWithActiveChangeSet") }, { BatchWriterAction.EndChangeset, null }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = false }, // OperationCreated - Read new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); if (tc.IsRequest) { return(new BatchWriterStatesTestSetupResult { Message = w.CreateOperationRequestMessage("GET", new Uri("http://odata.org")) }); } else { return(new BatchWriterStatesTestSetupResult { Message = w.CreateOperationResponseMessage() }); } }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationCreated") }, { BatchWriterAction.EndBatch, null }, { BatchWriterAction.StartChangeset, null }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // OperationStreamRequested - Read new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); if (tc.IsRequest) { return(GetOperationStream(w.CreateOperationRequestMessage("GET", new Uri("http://odata.org")), tc)); } else { return(GetOperationStream(w.CreateOperationResponseMessage(), tc)); } }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.Operation, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.GetOperationStream, ODataExpectedExceptions.ODataException("ODataBatchOperationMessage_VerifyNotCompleted") }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // OperationStreamDisposed - Read new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); BatchWriterStatesTestSetupResult result; if (tc.IsRequest) { result = GetOperationStream(w.CreateOperationRequestMessage("GET", new Uri("http://odata.org")), tc); } else { result = GetOperationStream(w.CreateOperationResponseMessage(), tc); } result.MessageStream.Dispose(); return(result); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamDisposed") }, { BatchWriterAction.EndBatch, null }, { BatchWriterAction.StartChangeset, null }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, ODataExpectedExceptions.ODataException("ODataBatchOperationMessage_VerifyNotCompleted") }, // Calling IDisposable.Dispose should not throw. { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // OperationCreated - Update new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteStartChangeset(); if (tc.IsRequest) { return(new BatchWriterStatesTestSetupResult { Message = w.CreateOperationRequestMessage("POST", new Uri("http://odata.org"), "1") }); } else { return(new BatchWriterStatesTestSetupResult { Message = w.CreateOperationResponseMessage() }); } }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationCreated") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteBatchWithActiveChangeSet") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotStartChangeSetWithActiveChangeSet") }, { BatchWriterAction.EndChangeset, null }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = false }, // OperationStreamRequested - Update new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteStartChangeset(); if (tc.IsRequest) { return(GetOperationStream(w.CreateOperationRequestMessage("POST", new Uri("http://odata.org"), "2"), tc)); } else { return(GetOperationStream(w.CreateOperationResponseMessage(), tc)); } }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.Operation, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamRequested") }, { BatchWriterAction.GetOperationStream, ODataExpectedExceptions.ODataException("ODataBatchOperationMessage_VerifyNotCompleted") }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = false }, // OperationStreamDisposed - Update new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteStartChangeset(); BatchWriterStatesTestSetupResult result; if (tc.IsRequest) { result = GetOperationStream(w.CreateOperationRequestMessage("POST", new Uri("http://odata.org"), "3"), tc); } else { result = GetOperationStream(w.CreateOperationResponseMessage(), tc); } result.MessageStream.Dispose(); return(result); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromOperationContentStreamDisposed") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteBatchWithActiveChangeSet") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotStartChangeSetWithActiveChangeSet") }, { BatchWriterAction.EndChangeset, null }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, ODataExpectedExceptions.ODataException("ODataBatchOperationMessage_VerifyNotCompleted") }, // Calling IDisposable.Dispose should not throw. { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = false }, // ChangeSetCompleted new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteStartChangeset(); w.WriteEndChangeset(); return(null); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromChangeSetCompleted") }, { BatchWriterAction.EndBatch, null }, { BatchWriterAction.StartChangeset, null }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, null }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // BatchCompleted new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { w.WriteStartBatch(); w.WriteEndBatch(); return(null); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromBatchCompleted") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromBatchCompleted") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromBatchCompleted") }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, ODataExpectedExceptions.ODataException("ODataBatchWriter_InvalidTransitionFromBatchCompleted") }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, // FatalExceptionThrown new BatchWriterStatesTestDescriptor { Setup = (w, s, tc) => { s.FailNextCall = true; w.WriteStartBatch(); if (tc.IsRequest) { w.CreateOperationRequestMessage("GET", new Uri("http://odata.org")); } else { w.CreateOperationResponseMessage(); } TestExceptionUtils.RunCatching(() => w.Flush()); return(null); }, ExpectedResults = new Dictionary <BatchWriterAction, ExpectedException> { { BatchWriterAction.StartBatch, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "BatchStarted") }, { BatchWriterAction.EndBatch, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "BatchCompleted") }, { BatchWriterAction.StartChangeset, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "ChangeSetStarted") }, { BatchWriterAction.EndChangeset, ODataExpectedExceptions.ODataException("ODataBatchWriter_CannotCompleteChangeSetWithoutActiveChangeSet") }, { BatchWriterAction.Operation, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "OperationCreated") }, { BatchWriterAction.GetOperationStream, null }, { BatchWriterAction.DisposeOperationStream, null }, }, ReadOperationReady = true }, }; this.CombinatorialEngineProvider.RunCombinations( testCases, EnumExtensionMethods.GetValues <BatchWriterAction>().Cast <BatchWriterAction>(), this.WriterTestConfigurationProvider.DefaultFormatConfigurations, (testCase, writerAction, testConfiguration) => { using (TestStream stream = new TestStream()) { // We purposely don't use the using pattern around the messageWriter here. Disposing the message writer will // fail here because the writer is not left in a valid state. var messageWriter = TestWriterUtils.CreateMessageWriter(stream, testConfiguration, this.Assert); ODataBatchWriterTestWrapper writer = messageWriter.CreateODataBatchWriter(); BatchWriterStatesTestSetupResult setupResult = null; if (testCase.Setup != null) { setupResult = testCase.Setup(writer, stream, testConfiguration); } ExpectedException expectedException = testCase.ExpectedResults[writerAction]; TestExceptionUtils.ExpectedException( this.Assert, () => InvokeBatchWriterAction(writer, writerAction, testConfiguration, testCase.ReadOperationReady, setupResult), expectedException, this.ExceptionVerifier); } }); }
public void ContentTypeHeaderParsingTest() { IEnumerable <ContentTypeTestCase> testCases = new ContentTypeTestCase[] { #region Atom test cases new ContentTypeTestCase { // only reading an entry or feed should succeed ContentType = "application/atom+xml;type=feed", ExpectedFormat = ODataFormat.Atom, }, new ContentTypeTestCase { // only reading an entry or feed should succeed ContentType = "application/atom+xml;type=entry", ExpectedFormat = ODataFormat.Atom, }, new ContentTypeTestCase { // reading a feed, an entry, and metadata should succeed ContentType = "application/atom+xml", ExpectedFormat = ODataFormat.Atom, }, new ContentTypeTestCase { // reading a property, an entity reference link, entity reference links, a collection, a service document, and an error should succeed ContentType = "application/xml", ExpectedFormat = ODataFormat.Atom, }, new ContentTypeTestCase { // reading a property, an entity reference link, entity reference links, and a collection should succeed ContentType = "text/xml", ExpectedFormat = ODataFormat.Atom, }, new ContentTypeTestCase { // reading a service document should succeed ContentType = "application/atomsvc+xml", ExpectedFormat = ODataFormat.Atom, }, #endregion Atom test cases #region RawValue test cases new ContentTypeTestCase { // only reading a raw value will succeed ContentType = "text/plain", ExpectedFormat = ODataFormat.RawValue, ShouldSucceedForPayloadKind = pk => pk == ODataPayloadKind.Value || pk == ODataPayloadKind.BinaryValue, }, new ContentTypeTestCase { // only reading a raw value or binary value will succeed; raw values can be read as binary values when the content type is application/octet-stream ContentType = "application/octet-stream", ExpectedFormat = ODataFormat.RawValue, ShouldSucceedForPayloadKind = pk => pk == ODataPayloadKind.Value || pk == ODataPayloadKind.BinaryValue, }, new ContentTypeTestCase { // only raw value / binary value will succeed ContentType = "multipart/mixed", ExpectedFormat = ODataFormat.RawValue, ShouldSucceedForPayloadKind = pk => false, }, new ContentTypeTestCase { // Test for: MimeType allows 0x7F character, but ContentType parsing doesn't ContentType = "application/" + 0x7F, ExpectedFormat = ODataFormat.RawValue, ShouldSucceedForPayloadKind = pk => false, }, #endregion RawValue test cases #region JSON Lite test cases new ContentTypeTestCase { // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest) ContentType = ApplicationJsonODataLight, ExpectedFormat = ODataFormat.Json, ShouldSucceedForPayloadKind = pk => pk != ODataPayloadKind.Value && pk != ODataPayloadKind.BinaryValue, }, new ContentTypeTestCase { // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest) ContentType = ApplicationJsonODataLightStreaming, ExpectedFormat = ODataFormat.Json, ShouldSucceedForPayloadKind = pk => pk != ODataPayloadKind.Value && pk != ODataPayloadKind.BinaryValue, }, new ContentTypeTestCase { // only batch and raw value will fail (batch payload kind tested separately in BatchContentTypeHeaderParsingTest) ContentType = ApplicationJsonODataLightNonStreaming, ExpectedFormat = ODataFormat.Json, ShouldSucceedForPayloadKind = pk => pk != ODataPayloadKind.Value && pk != ODataPayloadKind.BinaryValue, }, #endregion JSON Lite test cases #region Error test cases new ContentTypeTestCase { // unsupported content type; everything will fail ContentType = "application/foo", ShouldSucceedForPayloadKind = pk => false, }, new ContentTypeTestCase { // unsupported content type with parameters; everything will fail ContentType = "abc/pqr;a=b;c=d", ShouldSucceedForPayloadKind = pk => false, }, new ContentTypeTestCase { // "image/jpeg" is not supported, even for raw values. ContentType = "image/jpeg", ShouldSucceedForPayloadKind = pk => false, }, #endregion Error test cases #region Content Type is null or empty new ContentTypeTestCase { // null content type and zero content length should be default to Json if the payload kind is not binary value or value. ContentType = null, ContentLength = 0, ExpectedFormat = ODataFormat.Json, ShouldSucceedForPayloadKind = pk => true, ShouldIgnoreTest = pk => pk == ODataPayloadKind.BinaryValue || pk == ODataPayloadKind.Value }, new ContentTypeTestCase { // null content type and zero content length should be default to RawValue if the payload kind is binary value or value. ContentType = null, ContentLength = 0, ExpectedFormat = ODataFormat.RawValue, ShouldSucceedForPayloadKind = pk => true, ShouldIgnoreTest = pk => pk != ODataPayloadKind.Value }, #endregion }; string[] parameters = new string[] { "foo=bar", "foo1=bar1;foo2=bar2" }; testCases = testCases.Concat(testCases.Where(tc => tc.ContentType != null).SelectMany(tc => parameters.Select(p => new ContentTypeTestCase(tc) { ContentType = tc.ContentType + ";" + p }))); int oDataPayloadKindCount = EnumExtensionMethods.GetValues <ODataPayloadKind>().Length; this.Assert.AreEqual(oDataPayloadKindCount, TestReaderUtils.ODataPayloadKinds.Length, "The number of payload kind have changed, please update this test."); IEdmModel model = Microsoft.Test.OData.Utils.Metadata.TestModels.BuildTestModel(); // We don't support batch payloads here; we test those separately in BatchContentTypeHeaderParsingTest IEnumerable <ODataPayloadKind> payloadKinds = TestReaderUtils.ODataPayloadKinds.Where(k => k != ODataPayloadKind.Batch && k != ODataPayloadKind.Unsupported); this.CombinatorialEngineProvider.RunCombinations( testCases, payloadKinds, this.ReaderTestConfigurationProvider.AllFormatConfigurations, (testCase, payloadKind, testConfiguration) => { testConfiguration = new ReaderTestConfiguration(testConfiguration); testConfiguration.MessageReaderSettings.EnableAtom = false; if (IgnoreTestCase(payloadKind, testConfiguration)) { return; } if (testCase.ShouldIgnoreTest != null && testCase.ShouldIgnoreTest(payloadKind)) { return; } string supportedMediaTypes; if (payloadKind == ODataPayloadKind.Value || payloadKind == ODataPayloadKind.BinaryValue) { supportedMediaTypes = TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.Value) + ", " + TestMediaTypeUtils.GetSupportedMediaTypes(ODataPayloadKind.BinaryValue); } else { supportedMediaTypes = TestMediaTypeUtils.GetSupportedMediaTypes(payloadKind, /*includeAppJson*/ true); } ExpectedException expectedException = testCase.ExpectedException == null ? testCase.ShouldSucceedForPayloadKind != null && testCase.ShouldSucceedForPayloadKind(payloadKind) ? null : ODataExpectedExceptions.ODataContentTypeException("MediaTypeUtils_CannotDetermineFormatFromContentType", supportedMediaTypes, testCase.ContentType ?? "") : testCase.ExpectedException; // Make sure to run success test cases only in configurations that will work. if (expectedException == null && testConfiguration.Format != null && testCase.ExpectedFormat != testConfiguration.Format) { return; } ODataPayloadElement payloadElement = CreatePayloadElement(model, payloadKind, testConfiguration); // When we write a value with a content type different than 'text/plain', we will read it as binary. // Likewise, when we write a binary value with a 'text/plain' content type, we will read it as a string. Func <ReaderTestConfiguration, ODataPayloadElement> expectedResultElementFunc = null; if (payloadKind == ODataPayloadKind.Value && testCase.ContentType != null && !testCase.ContentType.StartsWith("text/plain")) { expectedResultElementFunc = (testConfig) => ConvertToBinaryPayloadElement(payloadElement); } else if (payloadKind == ODataPayloadKind.BinaryValue && testCase.ContentType != null && testCase.ContentType.StartsWith("text/plain")) { expectedResultElementFunc = (testConfig) => ConvertToStringPayloadElement(payloadElement); } ODataFormat expectedFormat = testCase.ExpectedFormat; ReaderContentTypeTestDescriptor testDescriptor = new ReaderContentTypeTestDescriptor(this.Settings) { PayloadElement = payloadElement, ExpectedResultPayloadElement = expectedResultElementFunc, PayloadEdmModel = model, ExpectedFormat = expectedFormat, ContentType = testCase.ContentType, ExpectedException = expectedException }; testDescriptor.RunTest(testConfiguration); testConfiguration.MessageReaderSettings.EnableAtom = true; }); }
private void WriterStatesTestImplementation(bool feedWriter) { var testCases = new WriterStatesTestDescriptor[] { // Start new WriterStatesTestDescriptor { Setup = null, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, feedWriter ? ODataExpectedExceptions.ODataException("ODataWriterCore_CannotWriteTopLevelResourceWithResourceSetWriter") : (ExpectedException)null }, { WriterAction.StartFeed, feedWriter ? (ExpectedException)null : ODataExpectedExceptions.ODataException("ODataWriterCore_CannotWriteTopLevelResourceSetWithResourceWriter") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromStart", "Start", "NavigationLink") }, { WriterAction.End, ODataExpectedExceptions.ODataException("ODataWriterCore_WriteEndCalledInInvalidState", "Start") }, { WriterAction.Error, null }, } }, // Entry new WriterStatesTestDescriptor { Setup = (mw, w, s) => { if (feedWriter) { w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); } w.WriteStart(ObjectModelUtils.CreateDefaultEntry()); }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromResource", "Entry", "Entry") }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromResource", "Entry", "Feed") }, { WriterAction.StartLink, null }, { WriterAction.End, null }, { WriterAction.Error, null }, } }, // Feed new WriterStatesTestDescriptor { Setup = (mw, w, s) => { if (feedWriter) { w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); } else { w.WriteStart(ObjectModelUtils.CreateDefaultEntry()); w.WriteStart(ObjectModelUtils.CreateDefaultCollectionLink()); w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); } }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, null }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromResourceSet", "Feed", "Feed") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromResourceSet", "Feed", "NavigationLink") }, { WriterAction.End, null }, { WriterAction.Error, null }, } }, // Link - single new WriterStatesTestDescriptor { Setup = (mw, w, s) => { if (feedWriter) { w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); } w.WriteStart(ObjectModelUtils.CreateDefaultEntry()); w.WriteStart(new ODataNestedResourceInfo { Name = ObjectModelUtils.DefaultLinkName, Url = ObjectModelUtils.DefaultLinkUrl, IsCollection = false }); }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, null }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("WriterValidationUtils_ExpandedLinkIsCollectionFalseWithResourceSetContent", "http://odata.org/link") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidStateTransition", "NavigationLink", "NavigationLink") }, { WriterAction.End, null }, { WriterAction.Error, null }, }, SkipForTestConfiguration = tc => tc.IsRequest }, // Link - collection new WriterStatesTestDescriptor { Setup = (mw, w, s) => { if (feedWriter) { w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); } w.WriteStart(ObjectModelUtils.CreateDefaultEntry()); w.WriteStart(ObjectModelUtils.CreateDefaultCollectionLink()); }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, ODataExpectedExceptions.ODataException("WriterValidationUtils_ExpandedLinkIsCollectionTrueWithResourceContent", "http://odata.org/link") }, { WriterAction.StartFeed, null }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidStateTransition", "NavigationLink", "NavigationLink") }, { WriterAction.End, null }, { WriterAction.Error, null }, }, SkipForTestConfiguration = tc => tc.IsRequest }, // Expanded link - there's no way to get to the expanded link state alone since the writer will always // immediately transition to either entry or feed state instead. // Completed new WriterStatesTestDescriptor { Setup = (mw, w, s) => { if (feedWriter) { w.WriteStart(ObjectModelUtils.CreateDefaultFeed()); w.WriteEnd(); } else { w.WriteStart(ObjectModelUtils.CreateDefaultEntry()); w.WriteEnd(); } }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromCompleted", "Completed", "Entry") }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromCompleted", "Completed", "Feed") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromCompleted", "Completed", "NavigationLink") }, { WriterAction.End, ODataExpectedExceptions.ODataException("ODataWriterCore_WriteEndCalledInInvalidState", "Completed") }, { WriterAction.Error, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromCompleted", "Completed", "Error") }, } }, // ODataExceptionThrown new WriterStatesTestDescriptor { Setup = (mw, w, s) => { TestExceptionUtils.RunCatching(() => w.WriteStart(ObjectModelUtils.CreateDefaultCollectionLink())); }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "Entry") }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "Feed") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "NavigationLink") }, { WriterAction.End, ODataExpectedExceptions.ODataException("ODataWriterCore_WriteEndCalledInInvalidState", "Error") }, { WriterAction.Error, null }, }, SkipForTestConfiguration = tc => tc.IsRequest, }, // Error new WriterStatesTestDescriptor { Setup = (mw, w, s) => { mw.WriteError(new ODataError(), false); }, ExpectedResults = new Dictionary <WriterAction, ExpectedException> { { WriterAction.StartResource, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "Entry") }, { WriterAction.StartFeed, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "Feed") }, { WriterAction.StartLink, ODataExpectedExceptions.ODataException("ODataWriterCore_InvalidTransitionFromError", "Error", "NavigationLink") }, { WriterAction.End, ODataExpectedExceptions.ODataException("ODataWriterCore_WriteEndCalledInInvalidState", "Error") }, { WriterAction.Error, ODataExpectedExceptions.ODataException("ODataMessageWriter_WriteErrorAlreadyCalled") }, }, SkipForTestConfiguration = tc => tc.IsRequest, }, }; ExpectedException errorNotAllowedException = ODataExpectedExceptions.ODataException("ODataMessageWriter_ErrorPayloadInRequest"); this.CombinatorialEngineProvider.RunCombinations( testCases, EnumExtensionMethods.GetValues <WriterAction>().Cast <WriterAction>(), this.WriterTestConfigurationProvider.AtomFormatConfigurations, (testCase, writerAction, testConfiguration) => { testConfiguration = testConfiguration.Clone(); testConfiguration.MessageWriterSettings.SetServiceDocumentUri(ServiceDocumentUri); if (testCase.SkipForTestConfiguration != null && testCase.SkipForTestConfiguration(testConfiguration)) { return; } ExpectedException expectedExceptionOnError; if (testCase.ExpectedResults.TryGetValue(WriterAction.Error, out expectedExceptionOnError)) { if (testConfiguration.IsRequest) { testCase = new WriterStatesTestDescriptor(testCase); testCase.ExpectedResults[WriterAction.Error] = errorNotAllowedException; } } using (TestStream stream = new TestStream()) { // We purposely don't use the using pattern around the messageWriter here. Disposing the message writer will // fail here because the writer is not left in a valid state. var messageWriter = TestWriterUtils.CreateMessageWriter(stream, testConfiguration, this.Assert); ODataWriter writer = messageWriter.CreateODataWriter(feedWriter); TestExceptionUtils.ExpectedException( this.Assert, () => { if (testCase.Setup != null) { testCase.Setup(messageWriter, writer, stream); } this.InvokeWriterAction(messageWriter, writer, writerAction); }, testCase.ExpectedResults[writerAction], this.ExceptionVerifier); } }); }
public IActionResult GetTenderStatuses() { return(Ok(EnumExtensionMethods.GetValues <TenderStatus>())); }
public IActionResult GetPlacingWays() { return(Ok(EnumExtensionMethods.GetValues <PlacingWay>())); }