public void DefaultValuesTest() { ODataError error = new ODataError(); this.Assert.IsNull(error.ErrorCode, "Expected null default value for property 'ErrorCode'."); this.Assert.IsNull(error.Message, "Expected null default value for property 'Message'."); this.Assert.IsNull(error.InnerError, "Expected null default value for property 'InnerError'."); }
public override void WriteError(ODataError error, bool includeDebugInformation) { var schema = this.AvroWriter.UpdateSchema(error, null); var obj = ODataAvroConvert.FromODataObject(error, schema); this.AvroWriter.Write(obj); this.Flush(); }
public void PropertySettersNullTest() { ODataError error = new ODataError() { ErrorCode = "500", Message = "Fehler! Bitte kontaktieren Sie den Administrator!", Target = "any target", Details = new List<ODataErrorDetail> { new ODataErrorDetail { ErrorCode = "401", Message = "any msg", Target = "another target" } }, InnerError = new ODataInnerError { Message = "No inner error" }, }; error.ErrorCode = null; error.Message = null; error.Target = null; error.Details = null; error.InnerError = null; this.Assert.IsNull(error.ErrorCode, "Expected null default value for property 'ErrorCode'."); this.Assert.IsNull(error.Message, "Expected null default value for property 'Message'."); this.Assert.IsNull(error.Target, "Expected null default value for property 'Target'."); this.Assert.IsNull(error.Details, "Expected null default value for property 'Details'."); this.Assert.IsNull(error.InnerError, "Expected null default value for property 'InnerError'."); }
/// <summary> /// Extracts error details from an <see cref="ODataError"/>. /// </summary> /// <param name="error">The ODataError instance to extract the error details from.</param> /// <param name="code">A data service-defined string which serves as a substatus to the HTTP response code.</param> /// <param name="message">A human readable message describing the error.</param> internal static void GetErrorDetails(ODataError error, out string code, out string message) { Debug.Assert(error != null, "error != null"); code = error.ErrorCode ?? string.Empty; message = error.Message ?? string.Empty; }
public void PropertyGettersAndSettersTest() { string errorCode = "500"; string message = "Fehler! Bitte kontaktieren Sie den Administrator!"; var target = "any target"; var details = new List<ODataErrorDetail> { new ODataErrorDetail { ErrorCode = "401", Message = "any msg", Target = "another target" } }; ODataInnerError innerError = new ODataInnerError { Message = "No inner error" }; ODataError error = new ODataError() { ErrorCode = errorCode, Message = message, Target = target, Details = details, InnerError = innerError }; this.Assert.AreEqual(errorCode, error.ErrorCode, "Expected equal error code values."); this.Assert.AreEqual(message, error.Message, "Expected equal message values."); this.Assert.AreEqual(target, error.Target, "Expected equal target values."); this.Assert.AreSame(details, error.Details, "Expected equal error detail values."); this.Assert.AreSame(innerError, error.InnerError, "Expected equal inner error values."); }
public void WriteTopLevelErrorUsesProvidedMessage() { var result = SetupSerializerAndRunTest(null, serializer => { ODataError error = new ODataError { Message = "error message text" }; serializer.WriteTopLevelError(error, false); }); result.Should().Contain("\"message\":\"error message text\""); }
public void WriteTopLevelErrorUsesProvidedErrorCode() { var result = SetupSerializerAndRunTest(null, serializer => { ODataError error = new ODataError { ErrorCode = "Error Code" }; serializer.WriteTopLevelError(error, false); }); result.Should().Contain("\"code\":\"Error Code\""); }
private void BuildODataError(out ODataError error, out HttpStatusCode statusCode) { // Default to 500 (InternalServerError), it will be overried below if necessary. statusCode = HttpStatusCode.InternalServerError; ODataServiceException ose = this.HandledException as ODataServiceException; if (ose != null) { statusCode = ose.StatusCode; } ODataContentTypeException octe = this.HandledException as ODataContentTypeException; if (octe != null) { statusCode = HttpStatusCode.UnsupportedMediaType; } ODataUnrecognizedPathException oupe = this.HandledException as ODataUnrecognizedPathException; if (oupe != null) { statusCode = HttpStatusCode.NotFound; } ODataErrorException oee = this.HandledException as ODataErrorException; if (oee != null) { error = this.BuildODataError(statusCode, this.HandledException); if (!string.IsNullOrEmpty(oee.Error.ErrorCode)) { error.ErrorCode = oee.Error.ErrorCode; } if (!string.IsNullOrEmpty(oee.Error.Message)) { error.Message = oee.Error.Message; } if (oee.Error.InnerError != null) { error.InnerError = oee.Error.InnerError; } } else { // All the other exception will go here. error = this.BuildODataError(statusCode, this.HandledException); } }
/// <summary> /// Write an error message. /// </summary> /// <param name="writer">The Xml writer to write to.</param> /// <param name="error">The error instance to write.</param> /// <param name="includeDebugInformation">A flag indicating whether error details should be written (in debug mode only) or not.</param> /// <param name="maxInnerErrorDepth">The maximumum number of nested inner errors to allow.</param> internal static void WriteXmlError(XmlWriter writer, ODataError error, bool includeDebugInformation, int maxInnerErrorDepth) { Debug.Assert(writer != null, "writer != null"); Debug.Assert(error != null, "error != null"); string code, message; ErrorUtils.GetErrorDetails(error, out code, out message); ODataInnerError innerError = includeDebugInformation ? error.InnerError : null; WriteXmlError(writer, code, message, innerError, maxInnerErrorDepth); }
/// <summary> /// Compares two <see cref="ODataError"/> instances and returns true if they are equal. Otherwise returns false. /// </summary> /// <param name="first">The first <see cref="ODataError"/> to use in the comparison.</param> /// <param name="second">The second <see cref="ODataError"/> to use in the comparison.</param> /// <returns>true if the <paramref name="first"/> and <paramref name="second"/> error instances are equal; otherwise false.</returns> public static bool AreEqual(ODataError first, ODataError second) { if (first == null && second == null) return true; if (first == null || second == null) return false; if (string.CompareOrdinal(first.ErrorCode, second.ErrorCode) != 0) return false; if (string.CompareOrdinal(first.Message, second.Message) != 0) return false; if (!AreEqual(first.InnerError, second.InnerError)) return false; return true; }
/// <summary> /// Creates an ExpectedException for ODataErrorException typed exceptions. /// </summary> /// <param name="expectedODataError">The expected value of the exception's Error property.</param> /// <returns>An ExpectedException for this expected ODataException.</returns> public static ExpectedException ODataErrorException(ODataError expectedODataError) { var expectedException = new ExpectedException(typeof(ODataErrorException)); expectedException.CustomVerification = (e) => { if (!ODataObjectModelValidationUtils.AreEqual(expectedODataError, ((ODataErrorException)e).Error)) { throw new DataComparisonException("Expected ODataError instances to be equal."); } }; return expectedException; }
/// <summary> /// Creates an ExpectedException for ODataErrorException typed exceptions. /// </summary> /// <param name="expectedODataError">The expected value of the exception's Error property.</param> /// <param name="resourceKey">The resource key to look up the expected message.</param> /// <param name="messageArguments">Arguments for the expected exception message.</param> /// <returns>An ExpectedException for this expected ODataException.</returns> public static ExpectedException ODataErrorException(ODataError expectedODataError, string resourceKey, params string[] messageArguments) { var expectedException = new ExpectedException(typeof(ODataErrorException), GetResourceVerifier(DataFxAssemblyRef.OData).CreateExpectedError(resourceKey, messageArguments)); expectedException.CustomVerification = (e) => { if (!ODataObjectModelValidationUtils.AreEqual(expectedODataError, ((ODataErrorException)e).Error)) { throw new DataComparisonException("Expected ODataError instances to be equal."); } }; return expectedException; }
public void ODataErrorSerializer_Works() { // Arrange ODataErrorSerializer serializer = new ODataErrorSerializer(); MemoryStream stream = new MemoryStream(); IODataResponseMessage message = new ODataMessageWrapper(stream); ODataError error = new ODataError { Message = "Error!!!" }; // Act serializer.WriteObject(error, typeof(ODataError), new ODataMessageWriter(message), new ODataSerializerContext()); // Assert stream.Seek(0, SeekOrigin.Begin); XElement element = XElement.Load(stream); Assert.Equal("Error!!!", element.Descendants().Single(e => e.Name.LocalName == "message").Value); }
public void PropertySettersNullTest() { ODataError error = new ODataError() { ErrorCode = "500", Message = "Fehler! Bitte kontaktieren Sie den Administrator!", InnerError = new ODataInnerError { Message = "No inner error" }, }; error.ErrorCode = null; error.Message = null; error.InnerError = null; this.Assert.IsNull(error.ErrorCode, "Expected null default value for property 'ErrorCode'."); this.Assert.IsNull(error.Message, "Expected null default value for property 'Message'."); this.Assert.IsNull(error.InnerError, "Expected null default value for property 'InnerError'."); }
public void PropertyGettersAndSettersTest() { string errorCode = "500"; string message = "Fehler! Bitte kontaktieren Sie den Administrator!"; ODataInnerError innerError = new ODataInnerError { Message = "No inner error" }; ODataError error = new ODataError() { ErrorCode = errorCode, Message = message, InnerError = innerError }; this.Assert.AreEqual(errorCode, error.ErrorCode, "Expected equal error code values."); this.Assert.AreEqual(message, error.Message, "Expected equal message values."); this.Assert.AreSame(innerError, error.InnerError, "Expected equal inner error values."); }
public void ODataErrorSerializer_Works() { // Arrange ODataErrorSerializer serializer = new ODataErrorSerializer(); MemoryStream stream = new MemoryStream(); IODataResponseMessage message = new ODataMessageWrapper(stream); ODataError error = new ODataError { Message = "Error!!!" }; ODataMessageWriterSettings settings = new ODataMessageWriterSettings(); settings.SetContentType(ODataFormat.Json); ODataMessageWriter writer = new ODataMessageWriter(message, settings); // Act serializer.WriteObject(error, typeof(ODataError), writer, new ODataSerializerContext()); stream.Seek(0, SeekOrigin.Begin); string result = new StreamReader(stream).ReadToEnd(); // Assert Assert.Equal("{\"error\":{\"code\":\"\",\"message\":\"Error!!!\"}}", result); }
/// <summary> /// Writes an <see cref="ODataError"/> into the message payload. /// </summary> /// <param name="error">The error to write.</param> /// <param name="includeDebugInformation"> /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should /// be included in the payload. This should only be used in debug scenarios. /// </param> /// <returns>Task which represents the pending write operation.</returns> /// <remarks> /// This method is called if the ODataMessageWriter.WriteError is called once some other /// write operation has already started. /// The method should write the in-stream error representation for the specific format into the current payload. /// Before the method is called no flush is performed on the output context or any active writer. /// It is the responsibility of this method to make sure that all the data up to this point are written before /// the in-stream error is written. /// It is the responsibility of this method to flush the output before the task finishes. /// </remarks> internal virtual Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation) { throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error); }
/// <summary> /// Writes an <see cref="ODataError"/> as the message payload. /// </summary> /// <param name="error">The error to write.</param> /// <param name="includeDebugInformation"> /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should /// be included in the payload. This should only be used in debug scenarios. /// </param> /// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks> public virtual void WriteError(ODataError error, bool includeDebugInformation) { throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error); }
public void UseWriterOnceTests() { Uri baseUri = new Uri("http://www.odata.org/"); ODataError error = new ODataError(); ODataEntityReferenceLink link = new ODataEntityReferenceLink { Url = new Uri("http://www.odata.org") }; ODataEntityReferenceLinks links = new ODataEntityReferenceLinks { Links = new ODataEntityReferenceLink[] { link, link, link }, }; ODataServiceDocument serviceDocument = ObjectModelUtils.CreateDefaultWorkspace(); ODataProperty property = new ODataProperty() { Name = "FirstName", Value = "Bill" }; object rawValue = 42; // TODO: add WriteMetadataDocumentAsync() here once implemented. UseWriterOnceTestCase[] messageWriterOperations = new UseWriterOnceTestCase[] { new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.CreateODataCollectionWriter() }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.CreateODataEntryWriter() }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.CreateODataEntryWriter() }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteError(error, false), IsWriteError = true }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteEntityReferenceLink(link) }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteEntityReferenceLinks(links) }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteProperty(property) }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteServiceDocument(serviceDocument) }, new UseWriterOnceTestCase { WriterMethod = (messageWriter) => messageWriter.WriteValue(rawValue), IsWriteValue = true }, }; var testCases = messageWriterOperations.Combinations(2); this.CombinatorialEngineProvider.RunCombinations( testCases, this.WriterTestConfigurationProvider.AtomFormatConfigurations.Where(tc => !tc.IsRequest), (testCase, testConfiguration) => { ODataMessageWriterSettings settingsWithBaseUri = testConfiguration.MessageWriterSettings.Clone(); settingsWithBaseUri.PayloadBaseUri = baseUri; settingsWithBaseUri.SetServiceDocumentUri(ServiceDocumentUri); using (var memoryStream = new TestStream()) { TestMessage testMessage; using (ODataMessageWriterTestWrapper messageWriter = TestWriterUtils.CreateMessageWriter(memoryStream, testConfiguration, this.Assert, out testMessage, settingsWithBaseUri)) { testCase[0].WriterMethod(messageWriter); string expectedException = "The ODataMessageWriter has already been used to write a message payload. An ODataMessageWriter can only be used once to write a payload for a given message."; if (testCase[0].IsWriteValue && testCase[1].IsWriteError) { expectedException = "The WriteError method or the WriteErrorAsync method on ODataMessageWriter cannot be called after the WriteValue method or the WriteValueAsync method is called. In OData, writing an in-stream error for raw values is not supported."; } else if (!testCase[0].IsWriteError && testCase[1].IsWriteError) { expectedException = null; } TestExceptionUtils.ExpectedException<ODataException>(this.Assert, () => testCase[1].WriterMethod(messageWriter), expectedException); } } }); }
/// <summary>Creates a new instance of the <see cref="T:Microsoft.OData.Core.ODataErrorException" /> class with an error message and an <see cref="T:Microsoft.OData.Core.ODataError" /> object.</summary> /// <param name="message">The plain text error message for this exception.</param> /// <param name="error">The <see cref="T:Microsoft.OData.Core.ODataError" /> instance representing the error read from the payload.</param> public ODataErrorException(string message, ODataError error) : this(message, null, error) { }
/// <summary>Creates a new instance of the <see cref="T:Microsoft.OData.Core.ODataErrorException" /> class with an <see cref="T:Microsoft.OData.Core.ODataError" /> object.</summary> /// <param name="error">The <see cref="T:Microsoft.OData.Core.ODataError" /> instance representing the error read from the payload.</param> /// <remarks> /// The Message property is initialized to a system-supplied message /// that describes the error. This message takes into account the /// current system culture. /// </remarks> public ODataErrorException(ODataError error) : this(Strings.ODataErrorException_GeneralError, null, error) { }
/// <summary> /// Writes an <see cref="ODataError"/> into the message payload. /// </summary> /// <param name="error">The error to write.</param> /// <param name="includeDebugInformation"> /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should /// be included in the payload. This should only be used in debug scenarios. /// </param> /// <returns>Task which represents the pending write operation.</returns> /// <remarks> /// This method is called if the ODataMessageWriter.WriteError is called once some other /// write operation has already started. /// The method should write the in-stream error representation for the specific format into the current payload. /// Before the method is called no flush is performed on the output context or any active writer. /// It is the responsibility of this method to make sure that all the data up to this point are written before /// the in-stream error is written. /// It is the responsibility of this method to flush the output before the task finishes. /// </remarks> internal virtual Task WriteInStreamErrorAsync(ODataError error, bool includeDebugInformation) { throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error); }
/// <summary>Creates a new instance of the <see cref="T:Microsoft.OData.Core.ODataErrorException" /> class with an error message, an inner exception, and an <see cref="T:Microsoft.OData.Core.ODataError" /> object.</summary> /// <param name="message">The plain text error message for this exception.</param> /// <param name="innerException">The inner exception that is the cause of this exception to be thrown.</param> /// <param name="error">The <see cref="T:Microsoft.OData.Core.ODataError" /> instance representing the error read from the payload.</param> public ODataErrorException(string message, Exception innerException, ODataError error) : base(message, innerException) { this.state.ODataError = error; }
/// <summary> /// Writes an <see cref="ODataError"/> into the message payload. /// </summary> /// <param name="error">The error to write.</param> /// <param name="includeDebugInformation"> /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should /// be included in the payload. This should only be used in debug scenarios. /// </param> /// <remarks> /// This method is called if the ODataMessageWriter.WriteError is called once some other /// write operation has already started. /// The method should write the in-stream error representation for the specific format into the current payload. /// Before the method is called no flush is performed on the output context or any active writer. /// It is the responsibility of this method to flush the output before the method returns. /// </remarks> internal override void WriteInStreamError(ODataError error, bool includeDebugInformation) { this.AssertSynchronous(); ODataAtomWriterUtils.WriteError(this.xmlWriter, error, includeDebugInformation, this.MessageWriterSettings.MessageQuotas.MaxNestingDepth); this.Flush(); }
public override void Visit(ODataErrorPayload payloadElement) { ExceptionUtilities.Assert(this.items.Count == 0, "Error should only be top level"); var error = new ODataError() { ErrorCode = payloadElement.Code, Message = payloadElement.Message }; this.items.Push(error); base.Visit(payloadElement); }
/// <summary> /// Converts an <see cref="ODataErrorpayload"/> into the corresponding <see cref="ODataError"/>. /// </summary> /// <param name="errorPayload">The error payload to convert.</param> /// <param name="forAtom">true if the conversion follows ATOM format rules; false for JSON format rules.</param> /// <returns>A new <see cref="ODataError"/> representing the <paramref name="errorPayload"/>.</returns> private static ODataError ConvertErrorPayload(ODataErrorPayload errorPayload, bool forAtom) { ODataError error = new ODataError(); error.ErrorCode = errorPayload.Code; error.Message = errorPayload.Message; ; ODataInternalExceptionPayload innerErrorPayload = errorPayload.InnerError; if (innerErrorPayload != null) { error.InnerError = ConvertInnerErrorPayload(innerErrorPayload); } return error; }
private static ODataValue RunBasicVerificationAndGetAnnotationValue(string name, ODataError error) { error.Should().NotBeNull(); var instanceAnnotations = error.InstanceAnnotations; instanceAnnotations.Should().NotBeNull("there was an instance annotation in the payload."); instanceAnnotations.Should().NotBeEmpty("there was an instance annotation in the payload."); var annotation = instanceAnnotations.Where(instanceAnnotation => instanceAnnotation.Name.Equals(name)).FirstOrDefault(); annotation.Should().NotBeNull("an instance annotation with the requested name was in the payload."); return annotation.Value; }
/// <summary> /// Writes an <see cref="ODataError"/> as the message payload. /// </summary> /// <param name="error">The error to write.</param> /// <param name="includeDebugInformation"> /// A flag indicating whether debug information (e.g., the inner error from the <paramref name="error"/>) should /// be included in the payload. This should only be used in debug scenarios. /// </param> /// <remarks>It is the responsibility of this method to flush the output before the method returns.</remarks> public virtual void WriteError(ODataError error, bool includeDebugInformation) { throw this.CreatePayloadKindNotSupportedException(ODataPayloadKind.Error); }
/// <summary> /// Writes an ODataError with the given custom instance annotation to the test stream. /// </summary> private void WriteError(params KeyValuePair<string, ODataValue>[] annotations) { var writerSettings = new ODataMessageWriterSettings { DisableMessageStreamDisposal = true }; writerSettings.SetContentType(ODataFormat.Json); writerSettings.SetServiceDocumentUri(new Uri("http://example.com/")); IODataResponseMessage messageToWrite = new InMemoryMessage { StatusCode = 400, Stream = this.stream }; var error = new ODataError(); var instanceAnnotations = new Collection<ODataInstanceAnnotation>(); error.SetInstanceAnnotations(instanceAnnotations); foreach (var pair in annotations) { ODataInstanceAnnotation annotation = new ODataInstanceAnnotation(pair.Key, pair.Value); instanceAnnotations.Add(annotation); } using (var writer = new ODataMessageWriter(messageToWrite, writerSettings, this.model)) { writer.WriteError(error, false); } }
/// <summary>Creates a new instance of the <see cref="T:Microsoft.OData.Core.ODataErrorException" /> class with an error message, an inner exception, and an <see cref="T:Microsoft.OData.Core.ODataError" /> object.</summary> /// <param name="message">The plain text error message for this exception.</param> /// <param name="innerException">The inner exception that is the cause of this exception to be thrown.</param> /// <param name="error">The <see cref="T:Microsoft.OData.Core.ODataError" /> instance representing the error read from the payload.</param> public ODataErrorException(string message, Exception innerException, ODataError error) : base(message, innerException) { this.state.ODataError = error; }
public void TestWriteError() { ODataError odataError = new ODataError() { ErrorCode = "404", Message = "Not Found", }; MemoryStream ms = new MemoryStream(); using (var omw = TestHelper.CreateMessageWriter(ms, "avro/binary", AvroMediaTypeResolver.Instance)) { omw.WriteError(odataError, false); } ms.Seek(0, SeekOrigin.Begin); Error error; IAvroReader<Error> reader = null; using (reader = AvroContainer.CreateReader<Error>(ms)) using (var seqReader = new SequentialReader<Error>(reader)) { error = seqReader.Objects.First(); } Assert.IsNotNull(error); Assert.AreEqual("404", error.ErrorCode); Assert.AreEqual("Not Found", error.Message); }
/// <summary>Creates a new instance of the <see cref="T:Microsoft.OData.Core.ODataErrorException" /> class with an error message and an <see cref="T:Microsoft.OData.Core.ODataError" /> object.</summary> /// <param name="message">The plain text error message for this exception.</param> /// <param name="error">The <see cref="T:Microsoft.OData.Core.ODataError" /> instance representing the error read from the payload.</param> public ODataErrorException(string message, ODataError error) : this(message, null, error) { }
/// <summary>Creates an ODataError instance describing the error.</summary> /// <returns>A new ODataError instance describing the error.</returns> internal ODataError CreateODataError() { ODataError error = new ODataError(); DataServiceException dataException = this.Exception as DataServiceException; if (dataException == null) { error.ErrorCode = String.Empty; error.Message = Strings.DataServiceException_GeneralError; if (this.UseVerboseErrors) { error.InnerError = new ODataInnerError(this.Exception); } } else { error.ErrorCode = dataException.ErrorCode ?? String.Empty; error.Message = dataException.Message ?? String.Empty; if (this.UseVerboseErrors && dataException.InnerException != null) { error.InnerError = new ODataInnerError(dataException.InnerException); } } error.InstanceAnnotations = this.InstanceAnnotations; return error; }
public void CreateErrorResponse_Respects_IncludeErrorDetail(IncludeErrorDetailPolicy errorDetail, bool? isLocal, bool? includeErrorDetail, bool detailIncluded) { HttpConfiguration config = new HttpConfiguration() { IncludeErrorDetailPolicy = errorDetail }; HttpRequestMessage request = new HttpRequestMessage(); request.SetConfiguration(config); if (isLocal.HasValue) { request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => isLocal.Value)); } if (includeErrorDetail.HasValue) { request.Properties.Add(HttpPropertyKeys.IncludeErrorDetailKey, new Lazy<bool>(() => includeErrorDetail.Value)); } ODataError error = new ODataError() { ErrorCode = "36", Message = "Bad stuff", InnerError = new ODataInnerError() { Message = "Exception message" } }; HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, error); Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode); ODataError contentError; Assert.True(response.TryGetContentValue<ODataError>(out contentError)); Assert.Equal("36", contentError.ErrorCode); Assert.Equal("Bad stuff", contentError.Message); if (detailIncluded) { Assert.NotNull(contentError.InnerError); Assert.Equal("Exception message", contentError.InnerError.Message); } else { Assert.Null(contentError.InnerError); } }
public void InitTest() { this.odataError = new ODataError(); }