public void SerializeError_Error_CanSerialize()
{
// Arrange
var error = new Error(HttpStatusCode.InsufficientStorage)
{
Title = "title", Detail = "detail"
};
var errorDocument = new ErrorDocument(error);
var expectedJson = JsonConvert.SerializeObject(new
{
errors = new[]
{
new
{
id = error.Id,
status = "507",
title = "title",
detail = "detail"
}
}
});
var serializer = GetResponseSerializer <OneToManyPrincipal>();
// Act
var result = serializer.Serialize(errorDocument);
// Assert
Assert.Equal(expectedJson, result);
}
public async Task WriteAsync(OutputFormatterWriteContext context)
{
ArgumentGuard.NotNull(context, nameof(context));
HttpResponse response = context.HttpContext.Response;
response.ContentType = _serializer.ContentType;
await using TextWriter writer = context.WriterFactory(response.Body, Encoding.UTF8);
string responseContent;
try
{
responseContent = SerializeResponse(context.Object, (HttpStatusCode)response.StatusCode);
}
#pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
catch (Exception exception)
#pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException
{
ErrorDocument errorDocument = _exceptionHandler.HandleException(exception);
responseContent = _serializer.Serialize(errorDocument);
response.StatusCode = (int)errorDocument.GetErrorStatusCode();
}
string url = context.HttpContext.Request.GetEncodedUrl();
_traceWriter.LogMessage(() => $"Sending {response.StatusCode} response for request at '{url}' with body: <<{responseContent}>>");
await writer.WriteAsync(responseContent);
await writer.FlushAsync();
}
private string SerializeErrorDocument(ErrorDocument errorDocument)
{
return(SerializeObject(errorDocument, _options.SerializerSettings, serializer =>
{
serializer.ApplyErrorSettings();
}));
}
public void GetErrors()
{
// Arrange
var fixture = new Fixture();
var id1 = fixture.Create <string>();
var id2 = fixture.Create <string>();
var applicationName = fixture.Create <string>();
var error1 = new Error(new Exception("error1"));
var error2 = new Error(new Exception("error2"));
var errorXml1 = ErrorXml.EncodeString(error1);
var errorXml2 = ErrorXml.EncodeString(error2);
var errorDoc1 = new ErrorDocument {
ErrorXml = errorXml1
};
var errorDoc2 = new ErrorDocument {
ErrorXml = errorXml2
};
var queryResponse = new Mock <ISearchResponse <ErrorDocument> >();
queryResponse.Setup(x => x.Total).Returns(2);
queryResponse.Setup(x => x.Hits).Returns(() =>
{
var mockHit1 = new Mock <IHit <ErrorDocument> >();
mockHit1.Setup(x => x.Id).Returns(id1);
mockHit1.Setup(x => x.Source).Returns(errorDoc1);
var mockHit2 = new Mock <IHit <ErrorDocument> >();
mockHit2.Setup(x => x.Id).Returns(id2);
mockHit2.Setup(x => x.Source).Returns(errorDoc2);
return(new[]
{
mockHit1.Object,
mockHit2.Object
});
});
queryResponse.Setup(x => x.IsValid).Returns(true);
_elasticClientMock
.Setup(x => x.Search(It.IsAny <Func <SearchDescriptor <ErrorDocument>, ISearchRequest> >()))
.Returns(queryResponse.Object);
var errorLog = new ElasticSearchErrorLog(_elasticClientMock.Object, new Hashtable())
{
ApplicationName = applicationName
};
// Act
var result = new ArrayList();
var count = errorLog.GetErrors(0, int.MaxValue, result);
// Assert
Assert.That(count, Is.EqualTo(2));
Assert.That(result.Count, Is.EqualTo(2));
}
protected IActionResult Error(IEnumerable <Error> errors)
{
var document = new ErrorDocument(errors);
return(new ObjectResult(document)
{
StatusCode = (int)document.GetErrorStatusCode()
});
}
// @formatter:wrap_array_initializer_style restore
public void ErrorDocument_GetErrorStatusCode_IsCorrect(HttpStatusCode[] errorCodes, HttpStatusCode expected)
{
// Arrange
var document = new ErrorDocument(errorCodes.Select(code => new Error(code)));
// Act
var status = document.GetErrorStatusCode();
// Assert
status.Should().Be(expected);
}
public void CanGetErrors()
{
// Arrange
var fixture = new Fixture();
var id1 = fixture.Create<string>();
var id2 = fixture.Create<string>();
var applicationName = fixture.Create<string>();
var error1 = new Error(new Exception("error1"));
var error2 = new Error(new Exception("error2"));
var errorXml1 = ErrorXml.EncodeString(error1);
var errorXml2 = ErrorXml.EncodeString(error2);
var errorDoc1 = new ErrorDocument {ErrorXml = errorXml1};
var errorDoc2 = new ErrorDocument {ErrorXml = errorXml2};
var queryResponse = new Mock<ISearchResponse<ErrorDocument>>();
queryResponse.Setup(x => x.Total).Returns(2);
queryResponse.Setup(x => x.Hits).Returns(() =>
{
var mockHit1 = new Mock<IHit<ErrorDocument>>();
mockHit1.Setup(x => x.Id).Returns(id1);
mockHit1.Setup(x => x.Source).Returns(errorDoc1);
var mockHit2 = new Mock<IHit<ErrorDocument>>();
mockHit2.Setup(x => x.Id).Returns(id2);
mockHit2.Setup(x => x.Source).Returns(errorDoc2);
return new[]
{
mockHit1.Object,
mockHit2.Object
};
});
queryResponse.Setup(x => x.IsValid).Returns(true);
_elasticClientMock
.Setup(x => x.Search(It.IsAny<Func<SearchDescriptor<ErrorDocument>, SearchDescriptor<ErrorDocument>>>()))
.Returns(queryResponse.Object);
var errorLog = new ElasticSearchErrorLog(_elasticClientMock.Object, new Hashtable())
{
ApplicationName = applicationName
};
// Act
var result = new ArrayList();
var count = errorLog.GetErrors(0, int.MaxValue, result);
// Assert
Assert.That(count, Is.EqualTo(2));
Assert.That(result.Count, Is.EqualTo(2));
}
protected IActionResult Error(IEnumerable <Error> errors)
{
ArgumentGuard.NotNull(errors, nameof(errors));
var document = new ErrorDocument(errors);
return(new ObjectResult(document)
{
StatusCode = (int)document.GetErrorStatusCode()
});
}
private static object WrapErrors(object contextObject)
{
if (contextObject is IEnumerable <Error> errors)
{
contextObject = new ErrorDocument(errors);
}
if (contextObject is Error error)
{
contextObject = new ErrorDocument(error);
}
return(contextObject);
}
protected IActionResult Error(IEnumerable <Error> errors)
{
if (errors == null)
{
throw new ArgumentNullException(nameof(errors));
}
var document = new ErrorDocument(errors);
return(new ObjectResult(document)
{
StatusCode = (int)document.GetErrorStatusCode()
});
}
/// <inheritdoc />
public Task OnExceptionAsync(ExceptionContext context)
{
ArgumentGuard.NotNull(context, nameof(context));
if (context.HttpContext.IsJsonApiRequest())
{
ErrorDocument errorDocument = _exceptionHandler.HandleException(context.Exception);
context.Result = new ObjectResult(errorDocument)
{
StatusCode = (int)errorDocument.GetErrorStatusCode()
};
}
return(Task.CompletedTask);
}
public void CanGetErrors()
{
// Arrange
var fixture = new Fixture();
var id1 = fixture.Create <string>();
var id2 = fixture.Create <string>();
var applicationName = fixture.Create <string>();
var error1 = new Error(new HttpException());
var error2 = new Error(new HttpException());
var errorXml1 = ErrorXml.EncodeString(error1);
var errorXml2 = ErrorXml.EncodeString(error2);
var errorDoc1 = new ErrorDocument {
ErrorXml = errorXml1, Id = id1
};
var errorDoc2 = new ErrorDocument {
ErrorXml = errorXml2, Id = id2
};
var elasticClientMock = new Mock <IElasticClient>();
var queryResponse = new Mock <IQueryResponse <ErrorDocument> >();
queryResponse.Setup(x => x.Total).Returns(2);
queryResponse.Setup(x => x.Documents).Returns(new[] { errorDoc1, errorDoc2 });
elasticClientMock
.Setup(x => x.Search(It.IsAny <Func <SearchDescriptor <ErrorDocument>, SearchDescriptor <ErrorDocument> > >()))
.Returns(queryResponse.Object);
var errorLog = new ElasticSearchErrorLog(elasticClientMock.Object)
{
ApplicationName = applicationName,
};
// Act
var result = new ArrayList();
var count = errorLog.GetErrors(0, int.MaxValue, result);
// Assert
Assert.That(count, Is.EqualTo(2));
Assert.That(result.Count, Is.EqualTo(2));
}
public async Task Serialize_ErrorDocument()
{
var error1 = new Mock <IError>(MockBehavior.Strict);
var error2 = new Mock <IError>(MockBehavior.Strict);
var mockErrorFormatter = new Mock <IErrorFormatter>(MockBehavior.Strict);
mockErrorFormatter.Setup(s => s.Serialize(error1.Object, It.IsAny <JsonWriter>()))
.Returns((IError error, JsonWriter writer) =>
{
writer.WriteValue("first error would go here");
return(Task.FromResult(0));
});
mockErrorFormatter.Setup(s => s.Serialize(error2.Object, It.IsAny <JsonWriter>()))
.Returns((IError error, JsonWriter writer) =>
{
writer.WriteValue("second error would go here");
return(Task.FromResult(0));
});
var mockMetadata = new Mock <IMetadata>(MockBehavior.Strict);
var mockMetadataFormatter = new Mock <IMetadataFormatter>(MockBehavior.Strict);
mockMetadataFormatter.Setup(s => s.Serialize(mockMetadata.Object, It.IsAny <JsonWriter>()))
.Returns((IMetadata metadata, JsonWriter writer) =>
{
writer.WriteValue("metadata goes here");
return(Task.FromResult(0));
});
IErrorDocument document = new ErrorDocument(new[] { error1.Object, error2.Object }, mockMetadata.Object);
var formatter = new ErrorDocumentFormatter(mockErrorFormatter.Object, mockMetadataFormatter.Object);
await AssertSerializeOutput(formatter, document, "Json/Fixtures/ErrorDocumentFormatter/Serialize_ErrorDocument.json");
}
public override string Log(Error error)
{
if (error == null)
{
throw new ArgumentNullException("error");
}
var errorDoc = new ErrorDocument
{
Error = error
};
using (var session = _documentStore.OpenSession(ApplicationName))
{
session.Store(errorDoc);
session.SaveChanges();
}
return errorDoc.Id;
}
