public void TestRepositoryBaseGetById()
{
using (var testDbInfo = SetupUtil.CreateFakeDb())
{
//Arrange
Mock <ILog> log = new Mock <ILog>();
List <Mock <FakeDto> > mockDtos = new List <Mock <FakeDto> >();
var repo = new FakeRepositoryBase(testDbInfo.ConnectionString, log.Object);
for (int i = 0; i < 10; i++)
{
Mock <FakeDto> mockDto = new Mock <FakeDto>();
mockDto.SetupGet(d => d.Name).Returns("Test Data " + (i + 1));
mockDto.SetupProperty(d => d.Id);
mockDtos.Add(mockDto);
repo.InsertProxy(mockDto.Object);
}
//Act
FakeDto id6 = repo.GetById(6);
//Assert
Assert.Equal(6, id6.Id);
Assert.Equal("Test Data 6", id6.Name);
}
}
public void Should_place_on_next_write_queue_if_auto_distribute_configured()
{
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue(), new FakeValidMessageQueue(), new FakeValidMessageQueue() };
var bus = new Bus(new FakeBusConfig {
AutoDistributeOnSend = true
}, new NullLogger(), new FakeValidMessageQueue(), new FakeValidMessageQueue(), writeQueues);
bus.Send(msg);
Assert.That(writeQueues[0].Count, Is.EqualTo(1));
Assert.That(writeQueues[1].Count, Is.EqualTo(0));
Assert.That(writeQueues[2].Count, Is.EqualTo(0));
bus.Send(msg);
Assert.That(writeQueues[0].Count, Is.EqualTo(1));
Assert.That(writeQueues[1].Count, Is.EqualTo(1));
Assert.That(writeQueues[2].Count, Is.EqualTo(0));
bus.Send(msg);
Assert.That(writeQueues[0].Count, Is.EqualTo(1));
Assert.That(writeQueues[1].Count, Is.EqualTo(1));
Assert.That(writeQueues[2].Count, Is.EqualTo(1));
}
public void Should_place_on_a_single_queue()
{
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue() };
var bus = new Bus(new FakeBusConfig(), new NullLogger(), new FakeValidMessageQueue(), new FakeValidMessageQueue(), writeQueues);
bus.Send(msg);
Assert.That(writeQueues[0].Count, Is.EqualTo(1));
}
public void Should_throw_when_destination_passed_in_and_queue_is_not_known()
{
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue("writeQueue1"), new FakeValidMessageQueue("writeQueue2"), new FakeValidMessageQueue("writeQueue3") };
var bus = new Bus(new FakeBusConfig(), new NullLogger(), new FakeValidMessageQueue("errorQueue"), new FakeValidMessageQueue("readQueue"), writeQueues);
var exception = Assert.Throws <BusException>(() => bus.Send(msg, "unknownQueue"));
Assert.That(exception.Message, Is.EqualTo("destination: 'unknownQueue' must be in the list of queues defined by the BusBuilder config via WriteQueue or WriteQueues"));
}
public void Should_place_on_all_write_queues_by_default()
{
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue("writeQueue1"), new FakeValidMessageQueue("writeQueue2"), new FakeValidMessageQueue("writeQueue3") };
var bus = new Bus(new FakeBusConfig(), new NullLogger(), new FakeValidMessageQueue("errorQueue"), new FakeValidMessageQueue("readQueue"), writeQueues);
bus.Send(msg);
Assert.That(writeQueues[0].Count, Is.EqualTo(1));
Assert.That(writeQueues[1].Count, Is.EqualTo(1));
Assert.That(writeQueues[2].Count, Is.EqualTo(1));
}
public async Task GetAsync_Success <TKey>(
TKey defaultKey,
FakeDto <TKey> item,
FakeDto <TKey> expectedResult)
{
// Arrange
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.GetAsync <FakeDto <TKey> >(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(item);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.GetAsync(defaultKey);
// Assert
mockRepository
.Verify(
x => x.GetAsync <FakeDto <TKey> >(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
Assert.Equal(expectedResult, result, new FakeDtoEqualityComparer <TKey>());
}
public void Should_place_on_requested_queue_when_destination_passed_in_and_queue_is_known()
{
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue("writeQueue1"), new FakeValidMessageQueue("writeQueue2"), new FakeValidMessageQueue("writeQueue3") };
var bus = new Bus(new FakeBusConfig(), new NullLogger(), new FakeValidMessageQueue("errorQueue"), new FakeValidMessageQueue("readQueue"), writeQueues);
bus.Send(msg, "writeQueue2");
Assert.That(writeQueues[0].Count, Is.EqualTo(0));
Assert.That(writeQueues[1].Count, Is.EqualTo(1));
Assert.That(writeQueues[2].Count, Is.EqualTo(0));
}
public void Should_log_all_steps_involved()
{
var logger = new FakeLogger();
var msg = new FakeDto();
var writeQueues = new[] { new FakeValidMessageQueue() };
var bus = new Bus(new FakeBusConfig(), logger, new FakeValidMessageQueue(), new FakeValidMessageQueue(), writeQueues);
bus.Send(msg);
Assert.That(logger[0], Is.StringEnding("Transaction started"));
Assert.That(logger[1], Is.StringEnding("Started SEND Operation"));
Assert.That(logger[2], Is.StringEnding("Payload: FakeDto"));
Assert.That(logger[3], Is.StringEnding("Sent to queue: FakeValidMessageQueue"));
Assert.That(logger[4], Is.StringEnding("Completed SEND Operation"));
Assert.That(logger[5], Is.StringEnding("Transaction committed"));
}
public void TestRepositoryBaseRemoveById()
{
using (var testDbInfo = SetupUtil.CreateFakeDb())
{
//Arrange
Mock <ILog> log = new Mock <ILog>();
List <Mock <FakeDto> > mockDtos = new List <Mock <FakeDto> >();
var repo = new FakeRepositoryBase(testDbInfo.ConnectionString, log.Object);
for (int i = 0; i < 10; i++)
{
Mock <FakeDto> mockDto = new Mock <FakeDto>();
mockDto.SetupGet(d => d.Name).Returns("Test Data " + (i + 1));
mockDto.SetupProperty(d => d.Id);
mockDtos.Add(mockDto);
repo.InsertProxy(mockDto.Object);
}
//Act
Mock <FakeDto> toRemove = mockDtos[5];
bool success = repo.RemoveById(toRemove.Object.Id.Value);
FakeDto removedDto = repo.GetById(toRemove.Object.Id.Value);
//Assert
//Ensure row was actually removed
Assert.True(success);
Assert.Null(removedDto);
//Ensure get removed dto failure was logged
log.Verify(l => l.WriteLine(It.IsAny <string>(), LogLevel.Error));
}
}
public async Task Should_call_its_handler_with_proper_url_supplied_getting_response_DTO()
{
// arrange
var expected = new FakeDto()
{
Id = 2,
Description = "Data"
};
HttpResponseMessage messageResponse = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(JsonConvert.SerializeObject(expected))
};
this.HttpMessageHandlerMock.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(messageResponse);
// act
var actual = await this.Sut.GetAsync <FakeDto>("data/2065", CancellationToken.None);
// assert
actual.Should().BeEquivalentTo(expected);
var expectedUri = new Uri($"{BaseUrl}data/2065");
this.HttpMessageHandlerMock.Protected()
.Verify("SendAsync",
Times.Once(),
ItExpr.Is <HttpRequestMessage>(req => req.Content == null && req.Method == HttpMethod.Get && req.RequestUri == expectedUri),
ItExpr.IsAny <CancellationToken>()
);
}
public async Task AddAsync_Success <TKey>(
TKey defaultKey,
FakeAddDto item,
FakeEntity <TKey> entity,
FakeDto <TKey> expectedResult)
{
// Arrange
Expression <Action <ILogger> > loggerExpressionAdd = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Add item: {item}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger.Setup(loggerExpressionAdd);
_mockBusinessMapper
.Setup(
x => x.Map <FakeAddDto, FakeEntity <TKey> >(item)
)
.Returns(entity);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.InsertAsync(entity)
)
.ReturnsAsync(entity);
Expression <Action <ILogger> > loggerExpressionSave = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
"Save changes"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Information))
.Returns(true);
_mockLogger.Setup(loggerExpressionSave);
_mockUnitOfWork
.Setup(
x => x.CommitAsync()
)
.ReturnsAsync(1);
_mockBusinessMapper
.Setup(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity)
)
.Returns(expectedResult);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.AddAsync(item);
// Assert
Assert.NotNull(defaultKey);
_mockLogger.Verify(loggerExpressionAdd, Times.Once);
_mockBusinessMapper
.Verify(
x => x.Map <FakeAddDto, FakeEntity <TKey> >(item),
Times.Once
);
mockRepository
.Verify(
x => x.InsertAsync(entity),
Times.Once
);
_mockLogger.Verify(loggerExpressionSave, Times.Once);
_mockUnitOfWork
.Verify(
x => x.CommitAsync(),
Times.Once
);
_mockBusinessMapper
.Verify(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity),
Times.Once
);
Assert.Equal(expectedResult, result, new FakeDtoEqualityComparer <TKey>());
}
public async Task EditAsync_Success <TKey>(
TKey defaultKey,
FakeEditDto <TKey> item,
FakeEntity <TKey> entity,
FakeDto <TKey> expectedResult)
{
// Arrange
Expression <Action <ILogger> > loggerExpressionEdit = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Edit item: {item}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Information))
.Returns(true);
_mockLogger.Setup(loggerExpressionEdit);
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(entity);
_mockBusinessMapper
.Setup(
x => x.Map(item, entity)
)
.Returns(entity);
mockRepository
.Setup(
x => x.Update(entity, false)
)
.Returns(entity);
Expression <Action <ILogger> > loggerExpressionSave = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
"Save changes"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger.Setup(loggerExpressionSave);
_mockUnitOfWork
.Setup(
x => x.CommitAsync()
)
.ReturnsAsync(1);
_mockBusinessMapper
.Setup(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity)
)
.Returns(expectedResult);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.EditAsync(item);
// Assert
_mockLogger.Verify(loggerExpressionEdit, Times.Once);
mockRepository
.Verify(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
_mockBusinessMapper
.Verify(
x => x.Map(item, entity),
Times.Once
);
mockRepository
.Verify(
x => x.Update(entity, false),
Times.Once
);
_mockLogger.Verify(loggerExpressionSave, Times.Once);
_mockUnitOfWork
.Verify(
x => x.CommitAsync(),
Times.Once
);
_mockBusinessMapper
.Verify(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity),
Times.Once
);
Assert.Equal(expectedResult, result, new FakeDtoEqualityComparer <TKey>());
}
