public async Task AddAsync__In_resource_exists_the_same_ticket_but_with_different_ticket_id_and_id__Should_add_this_ticket_successful()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Tickets.Add(_validTicket);
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
var ticket = _validTicket.Clone() as Ticket;
ticket.Id += "_changed_id";
ticket.Customer = await context.Customers.SingleAsync(x => x.Id.Equals(_validTicket.Customer.Id));
ticket.Discount = await context.Discounts.SingleAsync(x => x.Id.Equals(_validTicket.Discount.Id));
ticket.Tariff = await context.TicketTariffs.SingleAsync(x => x.Id.Equals(_validTicket.Tariff.Id));
ticket.Group = await context.Groups.SingleAsync(x => x.Id.Equals(_validTicket.Group.Id));
var result = await service.AddAsync(ticket);
result.Should().BeEquivalentTo(ticket);
}
}
}
public async Task AddAsync__In_resource_exists_the_same_ticket_but_with_different_ticket_id__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Tickets.Add(_validTicket);
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
var ticket = _validTicket.Clone() as Ticket;
// Assign existing customer, discount, ticket tariff and sightseeing group to the ticket to be added, based on their Ids.
// Each ticket is a child of mentioned entities and cannot exist without their.
// Moreover, it is impossible to add a new parent by adding a ticket that references a non-existent parent.
// In this case, an exception will be thrown.
ticket.Customer = await context.Customers.SingleAsync(x => x.Id.Equals(_validTicket.Customer.Id));
ticket.Discount = await context.Discounts.SingleAsync(x => x.Id.Equals(_validTicket.Discount.Id));
ticket.Tariff = await context.TicketTariffs.SingleAsync(x => x.Id.Equals(_validTicket.Tariff.Id));
ticket.Group = await context.Groups.SingleAsync(x => x.Id.Equals(_validTicket.Group.Id));
Func <Task> action = async() => await service.AddAsync(ticket);
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because in resource exists the Ticket with the same id as this one to be added.");
}
}
}
public async Task GetWithPaginationAsync__Number_of_elements_on_single_page_is_less_than_page_size__Should_return_all_these_elements()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Tickets.RemoveRange(await context.Tickets.ToArrayAsync());
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
for (int i = 0; i < 10; i++)
{
await context.Tickets.AddAsync(new Ticket { Id = i.ToString() });
}
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
// Page will be first with 6 elements and second with 4 elements. Second page will be return.
var result = await service.GetWithPaginationAsync(2, 6);
// More generic solution is: Count() should be count of elements in resource % pageSize.
result.Count().Should().Be(4);
}
}
}
public async Task Validate__Given_role_exist_in_db__Should_be_valid()
{
string role = "admin";
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Roles.Add(new IdentityRole {
Name = role, NormalizedName = role.ToUpper()
});
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var validRegisterVM = new RegisterViewModel {
Role = role
};
var validator = new RegisterViewModelValidator(context);
validator.ShouldNotHaveValidationErrorFor(x => x.Role, validRegisterVM);
}
}
}
public async Task RegisterAsync__Login_or_email_already_taken__Should_return_200OK_with_error()
{
string role = "role";
string email = "*****@*****.**";
string userName = "******";
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Users.Add(new IdentityUser
{
Email = email,
UserName = userName
});
context.Roles.Add(new IdentityRole(role));
await context.SaveChangesAsync();
}
}
var registerData = new RegisterViewModel {
EmailAddress = email, Password = "******", UserName = userName, Role = role
};
SetUpManagerForFailedRegister();
var controller = new UsersController(_userManagerMock.Object, _jwtTokenHandlerMock.Object, _refreshTokenManager, _logger, _mapperMock.Object);
var result = await controller.RegisterAsync(registerData);
result.Should().BeOfType <OkObjectResult>();
(result as OkObjectResult).StatusCode.Should().Be(200);
((result as OkObjectResult).Value as ResponseWrapper).Error.Should().NotBeEquivalentTo(new ApiError());
}
public async Task RegisterAsync__Register_successful__Should_return_201Created_with_user_data()
{
string role = "role";
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Users.RemoveRange(await context.Users.ToArrayAsync());
context.Roles.Add(new IdentityRole(role));
await context.SaveChangesAsync();
}
}
var registerData = new RegisterViewModel {
EmailAddress = "*****@*****.**", Password = "******", UserName = "******", Role = role
};
SetUpManagerForSuccessedRegister();
var controller = new UsersController(_userManagerMock.Object, _jwtTokenHandlerMock.Object, _refreshTokenManager, _logger, _mapperMock.Object);
var result = await controller.RegisterAsync(registerData);
(result as CreatedResult).StatusCode.Should().Be(201);
((result as CreatedResult).Value as ResponseWrapper).Data.Should().BeOfType <UserDto>();
((result as CreatedResult).Value as ResponseWrapper).Data.Should().NotBeEquivalentTo(new UserDto());
}
public async Task DeleteRefreshTokenAsync__Delete_successful__Resources_should_not_contain_deleted_refresh_token()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.Add(_validRefreshToken);
context.SaveChanges();
}
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
await manager.DeleteRefreshTokenAsync(_validRefreshToken);
context.RefreshTokens.Where(x => x.Token.Equals(_validRefreshToken.Token)).Count().Should().Be(0);
}
}
}
public async Task GetAsync__Resource_is_empty__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Tickets.RemoveRange(await context.Tickets.ToListAsync());
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
Func <Task> action = async() => await service.GetAsync("a");
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because resource is empty and cannot get single instance of Ticket.");
}
}
}
public async Task DeleteRefreshTokenAsync__Resource_is_empty__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.RemoveRange(await context.RefreshTokens.ToArrayAsync());
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.DeleteRefreshTokenAsync(_validRefreshToken);
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because resource is empty and cannot delete any element.");
}
}
}
public async Task AddAsync__In_resource_exists_the_same_activity_log_as_this_one_to_be_added__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.ActivityLogs.Add(_validActivityLog);
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new ActivityLogDbService(context, _logger);
Func <Task> result = async() => await service.AddAsync(_validActivityLog);
await result.Should().ThrowExactlyAsync <InvalidOperationException>("Because in resource exists the same ActivityLog as this one to be added.");
}
}
}
public async Task GetWithPaginationAsync__Resource_is_empty__Should_return_empty_IEnumerable()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Tickets.RemoveRange(await context.Tickets.ToArrayAsync());
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
var result = await service.GetWithPaginationAsync(4, 5);
result.Count().Should().Be(0);
}
}
}
public async Task AddRefreshToken__In_resource_exists_the_same_RefreshToken_as_this_one_to_be_added__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.Add(_validRefreshToken);
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.AddRefreshTokenAsync(_validRefreshToken);
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because in resource exists the same RefreshToken as this one to be added.");
}
}
}
public async Task GetAsync__Activity_log_found__Should_return_this_ActivityLog()
{
ActivityLog expectedActivityLog;
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
expectedActivityLog = await context.ActivityLogs.FirstOrDefaultAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new ActivityLogDbService(context, _logger);
var result = await service.GetAsync(expectedActivityLog.Id);
result.Should().BeEquivalentTo(expectedActivityLog);
}
}
}
public async Task GetByAsync__Resource_does_not_exist__Should_throw_InternalDbServiceException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
// Drop Tickets table.
context.Database.ExecuteSqlCommand("DROP TABLE [Tickets]");
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
Func <Task> action = async() => await service.GetByAsync(_predicate);
await action.Should().ThrowExactlyAsync <InternalDbServiceException>("Because resource doesnt exist and cannot get single instance of Ticket. " +
"NOTE Excaption actually is type of 'SqLiteError' only if database provider is SQLite.");
}
}
}
public async Task GetAsync__Ticket_found__Should_return_this_ticket()
{
Ticket expectedTicket;
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
expectedTicket = await context.Tickets.FirstOrDefaultAsync();
}
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
var result = await service.GetAsync(expectedTicket.Id);
result.Should().BeEquivalentTo(expectedTicket);
}
}
}
public async Task AddRefreshToken__Resource_does_not_exist__Should_throw_InternalDbmanagerException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
// Drop RefreshTokens table.
context.Database.ExecuteSqlCommand("DROP TABLE [RefreshTokens]");
}
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.AddRefreshTokenAsync(_validRefreshToken);
await action.Should().ThrowExactlyAsync <InternalDbServiceException>("Because resource doesnt exist and cannot get single instance of RefreshToken. " +
"NOTE Excaption actually is type of 'SqLiteError' only if database provider is SQLite.");
}
}
}
public async Task Validate__Given_role_does_not_exist_in_db__should_be_invalid()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.Roles.RemoveRange(await context.Roles.ToArrayAsync());
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
var invalidRegisterVM = new RegisterViewModel {
Role = "adasd"
};
var validator = new RegisterViewModelValidator(context);
validator.ShouldHaveValidationErrorFor(x => x.Role, invalidRegisterVM);
}
}
}
public async Task DeleteRefreshTokenAsync__RefreshToken_to_be_deleted_not_found__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.Add(new RefreshToken {
Id = Guid.NewGuid().ToString(), Token = "sample_new_token"
});
context.SaveChanges();
}
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.DeleteRefreshTokenAsync(_validRefreshToken);
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because RefreshToken to be deleted not found.");
}
}
}
public async Task DeleteRefreshTokenAsync__Delete_successful__Resources_length_should_be_less_by_1()
{
int expectedLength;
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.Add(_validRefreshToken);
context.SaveChanges();
}
using (var context = await factory.CreateContextAsync())
{
expectedLength = context.RefreshTokens.Count() - 1;
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
await manager.DeleteRefreshTokenAsync(_validRefreshToken);
context.RefreshTokens.Count().Should().Be(expectedLength);
}
}
}
public async Task AddAsync__Add_successful__Should_return_added_ticket_tariff()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
var result = await service.AddAsync(_validTicket);
result.Should().BeEquivalentTo(_validTicket);
}
}
}
public async Task DeleteRefreshTokenAsync__Argument_refresh_token_is_null__Should_throw_ArgumentNullException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.DeleteRefreshTokenAsync(null);
await action.Should().ThrowExactlyAsync <ArgumentNullException>();
}
}
}
public async Task GetSavedRefreshToken__Found_zero_matching_refresh_token__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.GetSavedRefreshTokenAsync(_validRefreshToken.Token);
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because RefreshToken not found.");
}
}
}
public async Task GetSavedRefreshToken__Arguemnt_refresh_token_is_null_or_empty__Should_throw_ArgumentNullException([Values(null, "")] string refreshToken)
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.GetSavedRefreshTokenAsync(refreshToken);
await action.Should().ThrowExactlyAsync <ArgumentException>("Because refreshToken cannot be null or empty.");
}
}
}
public async Task AddAsync__Add_successful__Resource_contains_added_ticket_tariff()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
await service.AddAsync(_validTicket);
context.Tickets.Contains(_validTicket).Should().BeTrue();
}
}
}
public async Task AddAsync__Add_successful__Resource_contains_added_ActivityLog()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var service = new ActivityLogDbService(context, _logger);
await service.AddAsync(_validActivityLog);
context.ActivityLogs.Contains(_validActivityLog).Should().BeTrue();
}
}
}
public async Task GetByAsync__Argument_predicate_is_null__Should_throw_ArgumentNullException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
Func <Task> action = async() => await service.GetByAsync(null);
await action.Should().ThrowExactlyAsync <ArgumentNullException>();
}
}
}
public async Task AddRefreshToken__Add_successful__Resource_contains_added_RefreshToken()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
await manager.AddRefreshTokenAsync(_validRefreshToken);
context.RefreshTokens.Contains(_validRefreshToken).Should().BeTrue();
}
}
}
public async Task GetAsync__Found_zero_matching_ticket__Should_throw_InvalidOperationException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
var service = new TicketDbService(context, _logger);
Func <Task> action = async() => await service.GetAsync("a");
await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because Ticket not found.");
}
}
}
public async Task GetSavedRefreshToken__RefreshToken_found__Should_return_this_RefreshToken()
{
RefreshToken expectedRefreshToken;
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens.Add(_validRefreshToken);
await context.SaveChangesAsync();
}
using (var context = await factory.CreateContextAsync())
{
expectedRefreshToken = await context.RefreshTokens.FirstOrDefaultAsync();
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
var result = await manager.GetSavedRefreshTokenAsync(expectedRefreshToken.Token);
result.Should().BeEquivalentTo(expectedRefreshToken);
}
}
}
public async Task AddRefreshToken__Resource_is_null__Should_throw_InternalDbServiceException()
{
using (var factory = new DbContextFactory())
{
using (var context = await factory.CreateContextAsync())
{
context.RefreshTokens = null as DbSet <RefreshToken>;
var manager = new RefreshTokenManager(context, _logger, _jwtOptions);
Func <Task> action = async() => await manager.AddRefreshTokenAsync(_validRefreshToken);
await action.Should().ThrowExactlyAsync <InternalDbServiceException>("Because resource reference is set to null");
}
}
}