public async Task when_handling_the_query_via_Post()
{
QueryName = "FakeQuery";
FakeQueryProcessor.Setup(x => x.GetQueryType(QueryName)).Returns(typeof(FakeQuery));
async Task should_return_the_result_from_the_query_processor()
{
var expected = new FakeResult();
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Returns(Task.FromResult(expected));
var result = await Subject.HandlePost(QueryName, Json) as OkNegotiatedContentResult <object>;
(await result.ExecuteAsync(CancellationToken.None)).StatusCode.Should().Be(200);
result.Content.Should().Be(expected);
}
async Task should_handle_QueryProcessorException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryProcessorException("fail"));
var result = await Subject.HandlePost(QueryName, Json);
await result.ShouldBeErrorAsync("fail", 400);
}
async Task should_handle_QueryException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryException("invalid"));
var result = await Subject.HandlePost(QueryName, Json);
await result.ShouldBeErrorAsync("invalid", 400);
}
async Task should_handle_Exception()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new Exception("fail"));
var result = await Subject.HandlePost(QueryName, Json);
await result.ShouldBeErrorAsync("fail", 500);
}
async Task should_log_errors()
{
var fakeTraceWriter = new Mock <ITraceWriter>();
var subject = new FakeQueryController(FakeQueryProcessor.Object, fakeTraceWriter.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new Exception("fail"));
await subject.HandlePost(QueryName, Json);
fakeTraceWriter.Verify(x => x.Trace(It.IsAny <HttpRequestMessage>(), "UnhandledQueryException", TraceLevel.Error, It.IsAny <Action <TraceRecord> >()));
}
}
public async Task ReturnsExecutedQueriesAsync()
{
// Arrange
var guid = Guid.NewGuid();
var queryProcessor = new FakeQueryProcessor();
// Act
await queryProcessor.ExecuteAsync(new TestQueryA(guid));
await queryProcessor.ExecuteAsync(new TestQueryB(100));
await queryProcessor.ExecuteAsync(new TestQueryB(200));
await queryProcessor.ExecuteAsync(new TestQueryB(300));
// Assert
queryProcessor.GetExecutedQueries().Count().ShouldBe(4);
queryProcessor.GetExecutedQueries <TestQueryA>().Count().ShouldBe(1);
queryProcessor.GetExecutedQueries <TestQueryB>().Count().ShouldBe(3);
queryProcessor.GetExecutedQueries <TestQueryC>().Count().ShouldBe(0);
queryProcessor.GetExecutedQueries <TestQueryA>().Single().Id.ShouldBe(guid);
queryProcessor.GetExecutedQueries <TestQueryB>().ElementAt(0).Number.ShouldBe(100);
queryProcessor.GetExecutedQueries <TestQueryB>().ElementAt(1).Number.ShouldBe(200);
queryProcessor.GetExecutedQueries <TestQueryB>().ElementAt(2).Number.ShouldBe(300);
}
public void Process_WithNotRegisteredHandler_ShouldThrowException()
{
// Assign
FakeUnregisteredQuery query = new FakeUnregisteredQuery();
IQueryProcessor processor = new FakeQueryProcessor();
// Act, Assert
Assert.Throws <ArgumentException>(() => processor.Process(query));
}
public void ThrowsForQueryWithThrowSetupMatchingPredicate()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupExceptionFor <TestQueryB>(q => q.Number == 1337, new AbandonedMutexException());
// Act + Assert
Assert.Throws <AbandonedMutexException>(() => queryProcessor.Execute(new TestQueryB(1337)));
}
public async Task ThrowsForQueryWithThrowSetupMatchingPredicateAsync()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupExceptionFor <TestQueryB>(q => q.Number == 1337, new AbandonedMutexException());
// Act + Assert
await Assert.ThrowsAsync <AbandonedMutexException>(async() => await queryProcessor.ExecuteAsync(new TestQueryB(1337)));
}
public void Process_WithRegisteredHandler_ShouldReturnNotNull()
{
// Assign
FakeQuery query = new FakeQuery();
IQueryProcessor processor = new FakeQueryProcessor();
// Act
FakeResult result = processor.Process(query);
// Assert
Assert.NotNull(result);
}
public void CanProcess_WithNotRegisteredHandler_ShouldReturnFalse()
{
// Assign
FakeUnregisteredQuery query = new FakeUnregisteredQuery();
IQueryProcessor processor = new FakeQueryProcessor();
// Act
bool canProcess = processor.CanProcess(query);
// Assert
Assert.False(canProcess);
}
public async Task ReturnsValueThatWasSetUpForQueryAsync()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupResultFor <TestQueryB>(1234);
// Act
var result = await queryProcessor.ExecuteAsync(new TestQueryB(1337));
// Assert
result.ShouldBe(1234);
}
public async Task ReturnsDefaultValueIfQueryDoesntMatchPredicateAsync()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupResultFor <TestQueryB>(q => q.Number == 1337, 1234);
// Act
var result = await queryProcessor.ExecuteAsync(new TestQueryB(9999));
// Assert
result.ShouldBe(default(int));
}
public async Task ReturnsComputedValueThatWasSetUpForQueryWithPredicateAsync()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupResultFor <TestQueryB>(q => q.Number == 1337, q => (int)q.Number);
// Act
var result = await queryProcessor.ExecuteAsync(new TestQueryB(1337));
// Assert
result.ShouldBe(1337);
}
public void ReturnsValueThatWasSetUpForQueryWithPredicate()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupResultFor <TestQueryB>(q => q.Number == 1337, 1234);
// Act
var result = queryProcessor.Execute(new TestQueryB(1337));
// Assert
result.ShouldBe(1234);
}
public void ReturnsDefaultValueOfQueriesWithoutSetup()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupResultFor <TestQueryB>(1234);
// Act
var result = queryProcessor.Execute(new TestQueryA(Guid.NewGuid()));
// Assert
result.ShouldBe(default(Guid));
}
public async Task DoesNotThrowIfQueryDoesntMatchPredicateAsync()
{
// Arrange
var queryProcessor = new FakeQueryProcessor();
queryProcessor.SetupExceptionFor <TestQueryB>(q => q.Number == 1337, new AbandonedMutexException());
// Act
var result = await queryProcessor.ExecuteAsync(new TestQueryB(9999));
// Assert
result.ShouldBe(default(int));
}
public async Task when_handling_the_query_via_Get()
{
Subject.Request.RequestUri = new Uri("http://example.com?foo=bar");
QueryName = "FakeQuery";
FakeQueryProcessor.Setup(x => x.GetQueryType(QueryName)).Returns(typeof(FakeQuery));
async Task should_return_the_result_from_the_query_processor()
{
var expected = new FakeResult();
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Returns(Task.FromResult(expected));
var result = await Subject.HandleGet(QueryName) as OkNegotiatedContentResult <object>;
(await result.ExecuteAsync(CancellationToken.None)).StatusCode.Should().Be(200);
result.Content.Should().Be(expected);
}
async Task should_handle_QueryProcessorException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryProcessorException("fail"));
var result = await Subject.HandleGet(QueryName);
await result.ShouldBeErrorAsync("fail", 400);
}
async Task should_handle_QueryException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryException("invalid"));
var result = await Subject.HandleGet(QueryName);
await result.ShouldBeErrorAsync("invalid", 400);
}
async Task should_handle_Exception()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new Exception("fail"));
var result = await Subject.HandleGet(QueryName);
await result.ShouldBeErrorAsync("fail", 500);
}
}
public async Task when_handling_the_query_via_Post()
{
QueryName = "FakeQuery";
Json = JObject.Parse("{}");
async Task should_invoke_the_query_processor()
{
await Subject.HandlePost(QueryName, Json);
FakeQueryProcessor.Verify(x => x.ProcessAsync <object>(QueryName, Json));
}
async Task should_return_the_result_from_the_query_processor()
{
var expected = new object();
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, Json)).Returns(Task.FromResult(expected));
var result = await Subject.HandlePost(QueryName, Json) as OkObjectResult;
result.Value.Should().Be(expected);
}
async Task should_handle_QueryValidationException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, Json)).Throws(new QueryValidationException("invalid"));
var result = await Subject.HandlePost(QueryName, Json) as BadRequestObjectResult;
result.ShouldBeError("invalid");
}
async Task should_handle_Exception()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, Json)).Throws(new Exception("fail"));
var result = await Subject.HandlePost(QueryName, Json) as ObjectResult;
result.StatusCode.Should().Be(500);
result.ShouldBeError("fail");
}
}
public async Task when_handling_the_query_via_Get()
{
QueryName = "FakeQuery";
async Task should_invoke_the_query_processor()
{
await Subject.HandleGet(QueryName);
FakeQueryProcessor.Verify(x => x.ProcessAsync <object>(QueryName, It.IsAny <IDictionary <string, IEnumerable <string> > >()));
}
async Task should_return_the_result_from_the_query_processor()
{
var expected = new object();
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, It.IsAny <IDictionary <string, IEnumerable <string> > >())).Returns(Task.FromResult(expected));
var result = await Subject.HandleGet(QueryName) as OkObjectResult;
result.Value.Should().Be(expected);
}
async Task should_handle_QueryValidationException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, It.IsAny <IDictionary <string, IEnumerable <string> > >())).Throws(new QueryValidationException("invalid"));
var result = await Subject.HandleGet(QueryName) as BadRequestObjectResult;
result.ShouldBeError("invalid");
}
async Task should_handle_Exception()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync <object>(QueryName, It.IsAny <IDictionary <string, IEnumerable <string> > >())).Throws(new Exception("fail"));
var result = await Subject.HandleGet(QueryName) as ObjectResult;
result.StatusCode.Should().Be(500);
result.ShouldBeError("fail");
}
}
public async Task when_handling_the_query_via_Get()
{
async Task should_return_the_result_from_the_query_processor()
{
var expected = new FakeResult();
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Returns(Task.FromResult(expected));
var result = await Subject.HandleGet(new FakeQuery()) as OkObjectResult;
result.StatusCode.Should().Be(200);
result.Value.Should().Be(expected);
}
async Task should_handle_QueryProcessorException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryProcessorException("fail"));
var result = await Subject.HandleGet(new FakeQuery());
result.ShouldBeError("fail", 400);
}
async Task should_handle_QueryException()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new QueryException("invalid"));
var result = await Subject.HandleGet(new FakeQuery());
result.ShouldBeError("invalid", 400);
}
async Task should_handle_Exception()
{
FakeQueryProcessor.Setup(x => x.ProcessAsync(It.IsAny <FakeQuery>())).Throws(new Exception("fail"));
var result = await Subject.HandleGet(new FakeQuery());
result.ShouldBeError("fail", 500);
}
}
