public async Task Handle_AllActivitiesExistAndBelongToSameCard_ReordersActivities()
{
var dbName = $"{nameof(ReorderActivitiesCommandHandlerTests)}_{nameof(Handle_AllActivitiesExistAndBelongToSameCard_ReordersActivities)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var card = Card.Create("card-title");
var activity1 = Activity.Create("activity1-title", 0);
var activity2 = Activity.Create("activity2-title", 1);
card.AddActivity(activity1);
card.AddActivity(activity2);
context.Cards.Add(card);
await context.SaveChangesAsync(cancellationToken);
var handler = new ReorderActivitiesCommandHandler(context, new ActivityService());
var request = new ReorderActivitiesCommand {
ActivityIds = new List <int> {
2, 1
}
};
await handler.Handle(request, cancellationToken);
var activity1FromDb = await context.Activities.FirstOrDefaultAsync(a => a.Id == 1, cancellationToken);
var activity2FromDb = await context.Activities.FirstOrDefaultAsync(a => a.Id == 2, cancellationToken);
Assert.NotNull(activity1FromDb);
Assert.NotNull(activity2FromDb);
Assert.Equal(0, activity2FromDb.Order);
Assert.Equal(1, activity1FromDb.Order);
}
public async Task Handle_AllCardsExistAndBelongToSameBoard_ReordersCards()
{
var dbName = $"{nameof(ReorderCardsCommandHandlerTests)}_{nameof(Handle_AllCardsExistAndBelongToSameBoard_ReordersCards)}";
var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card1 = Card.Create("card1-title");
var card2 = Card.Create("card2-title");
board.AddCard(card1);
board.AddCard(card2);
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var handler = new ReorderCardsCommandHandler(context, new CardService());
var request = new ReorderCardsCommand {
CardIds = new List <int> {
2, 1
}
};
await handler.Handle(request, cancellationToken);
var card1FromDb = await context.Cards.FirstOrDefaultAsync(c => c.Id == 1, cancellationToken);
var card2FromDb = await context.Cards.FirstOrDefaultAsync(c => c.Id == 2, cancellationToken);
Assert.NotNull(card1FromDb);
Assert.NotNull(card2FromDb);
Assert.Equal(0, card2FromDb.Order);
Assert.Equal(1, card1FromDb.Order);
}
public async Task Handle_BoardIdExists_ReturnsBoardUserType()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnsBoardUserType)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var boardUserFactory = new BoardUserFactory();
var userId = "user-id";
var board = boardFactory.Create("board-title");
var boardUser = boardUserFactory.CreateOwner(1, userId);
var boardUserType = boardUser.Type.ToString().ToLower();
context.Boards.Add(board);
context.BoardUsers.Add(boardUser);
await context.SaveChangesAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
Assert.Equal(boardUserType, dto.BoardUserType);
}
public async Task Handle_AccessCodeFound_CreateBoardUser()
{
var dbName = $"{nameof(JoinBoardCommandHandlerTests)}_{nameof(Handle_AccessCodeFound_CreateBoardUser)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var userId = "user-id";
_currentUser.Setup(u => u.UserId).Returns(userId);
var handler = new JoinBoardCommandHandler(context, _currentUser.Object, new BoardUserFactory());
var command = new JoinBoardCommand {
AccessCode = board.AccessCode
};
var dto = await handler.Handle(command, cancellationToken);
var boardUser = await context.BoardUsers
.FirstOrDefaultAsync(bu => bu.BoardId == board.Id && bu.UserId == userId);
Assert.NotNull(boardUser);
Assert.Equal(board.Id, dto.BoardId);
}
public async Task Handle_AnyCardNotBelongsToSameBoard_ThrowsInvalidOperationApplicationException()
{
var dbName = $"{nameof(ReorderCardsCommandHandlerTests)}_{nameof(Handle_AnyCardNotBelongsToSameBoard_ThrowsInvalidOperationApplicationException)}";
var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board1 = boardFactory.Create("board1-title");
var board2 = boardFactory.Create("board2-title");
var card1 = Card.Create("card1-title");
var card2 = Card.Create("card2-title");
board1.AddCard(card1);
board2.AddCard(card2);
context.Boards.AddRange(board1, board2);
await context.SaveChangesAsync(cancellationToken);
var handler = new ReorderCardsCommandHandler(context, new CardService());
var request = new ReorderCardsCommand {
CardIds = new List <int> {
1, 2
}
};
Task <Unit> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <InvalidOperationApplicationException>(action);
}
public async Task Handle_AnyActivityNotBelongsToSameCard_ThrowsInvalidOperationApplicationException()
{
var dbName = $"{nameof(ReorderActivitiesCommandHandlerTests)}_{nameof(Handle_AnyActivityNotBelongsToSameCard_ThrowsInvalidOperationApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var card1 = Card.Create("card1-title");
var card2 = Card.Create("card2-title");
var activity1 = Activity.Create("activity1-title");
var activity2 = Activity.Create("activity2-title");
card1.AddActivity(activity1);
card2.AddActivity(activity2);
context.Cards.AddRange(card1, card2);
await context.SaveChangesAsync(cancellationToken);
var handler = new ReorderActivitiesCommandHandler(context, new ActivityService());
var request = new ReorderActivitiesCommand {
ActivityIds = new List <int> {
1, 2
}
};
Task <Unit> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <InvalidOperationApplicationException>(action);
}
public async Task Handle_BoardIdExists_ReturnDto()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnDto)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card = Card.Create("card-title");
var activity = Activity.Create("activity-title");
board.AddCard(card);
card.AddActivity(activity);
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
var dtoCard = dto.Cards.FirstOrDefault();
var dtoActivity = dtoCard.Activities.FirstOrDefault();
Assert.NotNull(dto);
Assert.Equal(1, dto.Id);
Assert.NotNull(dto.Cards);
Assert.Single(dto.Cards);
Assert.Equal(1, dtoCard.Id);
Assert.NotNull(dtoCard.Activities);
Assert.Single(dtoCard.Activities);
Assert.Equal(1, dtoActivity.Id);
}
public async Task Handle_BoardExists_ReturnsCardCreatedDtoWithCorrectPropValues()
{
var dbName = $"{nameof(AddCardToBoardCommandHandlerTests)}_{nameof(Handle_BoardExists_ReturnsCardCreatedDtoWithCorrectPropValues)}";
using var context = TestApplicationDbContext.Create(dbName);
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var cancellationToken = new CancellationToken();
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var handler = new AddCardToBoardCommandHandler(context);
var request = new AddCardToBoardCommand {
BoardId = board.Id, Title = "card-title"
};
var cardCreatedDto = await handler.Handle(request, cancellationToken);
var card = await context.Cards.FirstOrDefaultAsync(c => c.BoardId == board.Id);
Assert.NotNull(cardCreatedDto);
Assert.Equal(card.Id, cardCreatedDto.CardId);
Assert.Equal(card.BoardId, cardCreatedDto.BoardId);
}
public async Task HasPermissionForActivity_BoardUserExists_ReturnOutputOfIBoardUserPermissionService()
{
var userId = "user-id";
_currentUser.Setup(u => u.UserId).Returns(userId);
_boardUserPermissionService.Setup(s => s.HasPermission(It.IsAny <BoardUser>(), It.IsAny <BoardUserPermission>())).Returns(true);
var dbName = $"{nameof(CurrentUserPermissionServiceTests)}_{nameof(HasPermissionForActivity_BoardUserExists_ReturnOutputOfIBoardUserPermissionService)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card = Card.Create("card-title");
var activity = Activity.Create("activity-title");
var boardUser = new BoardUserFactory().CreateOwner(1, userId);
board.AddCard(card);
card.AddActivity(activity);
context.Boards.Add(board);
context.BoardUsers.Add(boardUser);
await context.SaveChangesAsync(cancellationToken);
var service = new CurrentUserPermissionService(context, _currentUser.Object, _boardUserPermissionService.Object);
var result = await service.HasPermissionForActivity(activity.Id, BoardUserPermission.CAN_VIEW_ACTIVITY, cancellationToken);
Assert.True(result);
}
public async Task CanCreateVehicleTestAsync()
{
//Arrange
TestApplicationDbContext tdb = new TestApplicationDbContext();
Vehicle vehicleToBeCreated = new Vehicle
{
Title = "Nissan Micra",
Price = 1250,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
//creating a controller
VehicleController controller = new VehicleController(tdb);
//Act
//call controller searchIndexMethod
var result = await controller.Create(vehicleToBeCreated);
//var result = viewResult.ViewData.Model as IEnumerable<VehicleModel>;
//Assert
//we are checking that a view called Index is returned
Assert.IsInstanceOfType(result, typeof(RedirectToRouteResult));
//view Result for the cannot create
}
public async Task Handle_BoardIdExists_EditsBoard()
{
var dbName = $"{nameof(EditBoardCommandHandlerTests)}_{nameof(Handle_BoardIdExists_EditsBoard)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var editedTitle = "edited-title";
var handler = new EditBoardCommandHandler(context);
var request = new EditBoardCommand {
BoardId = 1, Title = editedTitle
};
await handler.Handle(request, cancellationToken);
var boardFromDb = await context.Boards.FirstOrDefaultAsync(b => b.Id == 1, cancellationToken);
Assert.NotNull(boardFromDb);
Assert.Equal(editedTitle, boardFromDb.Title);
}
public async Task Handle_HasBoards_FiltersByBoardUser()
{
var factory = new BoardUserFactory();
var dbName = $"{nameof(GetBoardsListQueryHandlerTests)}_{nameof(Handle_HasBoards_FiltersByBoardUser)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var userId = "user-id";
_currentUser.Setup(u => u.UserId).Returns(userId);
var boardFactory = new BoardFactory();
var board1 = boardFactory.Create("board1-title");
var board2 = boardFactory.Create("board2-title");
var boardUser = factory.CreateOwner(1, userId);
context.Boards.AddRange(board1, board2);
context.BoardUsers.Add(boardUser);
await context.SaveChangesAsync(cancellationToken);
var handler = new GetBoardsListQueryHandler(context, _currentUser.Object);
var dto = await handler.Handle(new GetBoardsListQuery(), cancellationToken);
Assert.Single(dto.Boards);
Assert.Equal(boardUser.BoardId, dto.Boards.First().Id);
}
public async Task Handle_ActivityIdAndCardIdExist_SetsActivityOrderToNull()
{
var dbName = $"{nameof(MoveActivityToCardCommandHandlerTests)}_{nameof(Handle_ActivityIdAndCardIdExist_SetsActivityOrderToNull)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var card1 = Card.Create("card1-title");
var card2 = Card.Create("card2-title");
var activity = Activity.Create("activity-title", 1);
card1.AddActivity(activity);
context.Cards.AddRange(card1, card2);
await context.SaveChangesAsync(cancellationToken);
var handler = new MoveActivityToCardCommandHandler(context);
var request = new MoveActivityToCardCommand {
ActivityId = activity.Id, CardId = card2.Id
};
await handler.Handle(request, cancellationToken);
var activityFromDb = await context.Activities.FirstOrDefaultAsync(a => a.Id == activity.Id, cancellationToken);
Assert.Null(activityFromDb.Order);
}
public async Task Handle_BoardIdExists_ReturnsCardsInOrder()
{
var dbName = $"{nameof(GetBoardQueryHandlerTests)}_{nameof(Handle_BoardIdExists_ReturnsCardsInOrder)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var boardFactory = new BoardFactory();
var board = boardFactory.Create("board-title");
var card1 = Card.Create("card1-title", 1);
var card2 = Card.Create("card2-title", 0);
board.AddCard(card1);
board.AddCard(card2);
context.Boards.Add(board);
await context.SaveChangesAsync(cancellationToken);
var orderedCardIds = await context.Cards
.Where(c => c.BoardId == board.Id)
.OrderBy(c => c.Order)
.Select(c => c.Id)
.ToListAsync(cancellationToken);
var handler = new GetBoardQueryHandler(context);
var request = new GetBoardQuery(1);
var dto = await handler.Handle(request, cancellationToken);
var dtoCardIds = dto.Cards.Select(c => c.Id).ToList();
Assert.Equal(orderedCardIds, dtoCardIds);
}
public void Ctor_IBoardUserPermissionServiceNull_ThrowsArgumentNullException()
{
var dbName = $"{nameof(CurrentUserPermissionServiceTests)}_{nameof(Ctor_IBoardUserPermissionServiceNull_ThrowsArgumentNullException)}";
using var context = TestApplicationDbContext.Create(dbName);
Assert.Throws <ArgumentNullException>(() => new CurrentUserPermissionService(context, _currentUser.Object, null));
}
public void Ctor_IBoardFactory_ThrowsArgumentNullException()
{
var dbName = $"{nameof(CreateBoardCommandHandlerTests)}_{nameof(Ctor_IBoardFactory_ThrowsArgumentNullException)}";
using var context = TestApplicationDbContext.Create(dbName);
Assert.Throws <ArgumentNullException>(() => new CreateBoardCommandHandler(context, _currentUser.Object, null, new BoardUserFactory()));
}
public void Ctor_IActivityServiceNull_ThrowsArgumentNullException()
{
var dbName = $"{nameof(ReorderActivitiesCommandHandlerTests)}_{nameof(Ctor_IActivityServiceNull_ThrowsArgumentNullException)}";
using var context = TestApplicationDbContext.Create(dbName);
Assert.Throws <ArgumentNullException>(() => new ReorderActivitiesCommandHandler(context, null));
}
public void Ctor_ICurrentUserNull_ThrowsArgumentNullException()
{
var dbName = $"{nameof(GetBoardsListQueryHandlerTests)}_{nameof(Ctor_ICurrentUserNull_ThrowsArgumentNullException)}";
using var context = TestApplicationDbContext.Create(dbName);
Assert.Throws <ArgumentNullException>(() => new GetBoardsListQueryHandler(context, null));
}
public ApplicationUserServiceShould()
{
_mockRepository = new MockRepository(MockBehavior.Strict);
_mockVerveRoleStore = this._mockRepository.Create <IVerveRoleStore <VerveRole> >();
_mockTestApplicationDbContext = MockDbContext.Create();
_mockIdentityErrorDescriber = this._mockRepository.Create <IdentityErrorDescriber>();
_mockLogger = this._mockRepository.Create <ILogger <VerveIdentityService <TestApplicationDbContext, UserAccount, VerveRole> > >();
}
public async Task HasPermissionForActivity_ActivityNotExists_ThrowNotFoundApplicationException()
{
var dbName = $"{nameof(CurrentUserPermissionServiceTests)}_{nameof(HasPermissionForActivity_ActivityNotExists_ThrowNotFoundApplicationException)}";
var context = TestApplicationDbContext.Create(dbName);
var service = new CurrentUserPermissionService(context, _currentUser.Object, _boardUserPermissionService.Object);
Task action() => service.HasPermissionForActivity(1, BoardUserPermission.CAN_VIEW_ACTIVITY, new CancellationToken());
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task Handle_NoBoards_ReturnsEmptyList()
{
var dbName = $"{nameof(GetBoardsListQueryHandlerTests)}_{nameof(Handle_NoBoards_ReturnsEmptyList)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new GetBoardsListQueryHandler(context, _currentUser.Object);
var dto = await handler.Handle(new GetBoardsListQuery(), new CancellationToken());
Assert.NotNull(dto.Boards);
Assert.Empty(dto.Boards);
}
public async Task Handle_CardIdNotExists_ThrowsNotFoundApplicationException()
{
var dbName = $"{nameof(DeleteCardCommandHandlerTests)}_{nameof(Handle_CardIdNotExists_ThrowsNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new DeleteCardCommandHandler(context);
var request = new DeleteCardCommand(1);
var cancellationToken = new CancellationToken();
Task <Unit> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task Handle_ActivityIdNotExists_ThrowsNotFoundApplicationException()
{
var dbName = $"{nameof(EditActivityCommandHandlerTests)}_{nameof(Handle_ActivityIdNotExists_ThrowsNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new EditActivityCommandHandler(context);
var request = new EditActivityCommand {
ActivityId = 1, Title = "test-title", Description = "test-description"
};
var cancellationToken = new CancellationToken();
Task <Unit> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task Handle_AccessCodeNotFound_ThrowNotFoundApplicationException()
{
var dbName = $"{nameof(JoinBoardCommandHandlerTests)}_{nameof(Handle_AccessCodeNotFound_ThrowNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new JoinBoardCommandHandler(context, _currentUser.Object, new BoardUserFactory());
var command = new JoinBoardCommand {
AccessCode = "accessCode"
};
var cancellationToken = new CancellationToken();
Task <BoardJoinedDto> action() => handler.Handle(command, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task Handle_CardNotExists_ThrowsNotFoundApplicationException()
{
var dbName = $"{nameof(AddCardToBoardCommandHandlerTests)}_{nameof(Handle_CardNotExists_ThrowsNotFoundApplicationException)}";
using var context = TestApplicationDbContext.Create(dbName);
var boardId = 1;
var handler = new AddCardToBoardCommandHandler(context);
var request = new AddCardToBoardCommand {
BoardId = boardId, Title = "card-title"
};
var cancellationToken = new CancellationToken();
Task <CardCreatedDto> action() => handler.Handle(request, cancellationToken);
await Assert.ThrowsAsync <NotFoundApplicationException>(action);
}
public async Task Handle_CreatesBoard()
{
var dbName = $"{nameof(CreateBoardCommandHandlerTests)}_{nameof(Handle_CreatesBoard)}";
using var context = TestApplicationDbContext.Create(dbName);
var handler = new CreateBoardCommandHandler(context, _currentUser.Object, new BoardFactory(), new BoardUserFactory());
var request = new CreateBoardCommand {
Title = "test-title"
};
var cancellationToken = new CancellationToken();
await handler.Handle(request, cancellationToken);
var board = await context.Boards.FirstOrDefaultAsync(cancellationToken);
Assert.NotNull(board);
Assert.Equal(1, board.Id);
}
public async Task Handle_CardIdExists_DeleteCard()
{
var dbName = $"{nameof(DeleteCardCommandHandlerTests)}_{nameof(Handle_CardIdExists_DeleteCard)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var card = Card.Create("card-title");
context.Cards.Add(card);
await context.SaveChangesAsync(cancellationToken);
var handler = new DeleteCardCommandHandler(context);
var request = new DeleteCardCommand(1);
await handler.Handle(request, cancellationToken);
var cardFromDb = await context.Cards.FirstOrDefaultAsync(c => c.Id == 1);
Assert.Null(cardFromDb);
}
public static void SeedRoles(TestApplicationDbContext mockDbContext)
{
mockDbContext.Roles.Add(new VerveRole
{
Id = StaticGuids.One,
Name = "Admin",
NormalizedName = "ADMIN",
Description = "Administrator"
});
mockDbContext.Roles.Add(new VerveRole
{
Id = StaticGuids.Two,
Name = "User",
NormalizedName = "USER",
Description = "User"
});
mockDbContext.SaveChanges();
}
public async Task Handle_ActivityIdExists_DeletesActivity()
{
var dbName = $"{nameof(DeleteActivityCommandHandlerTests)}_{nameof(Handle_ActivityIdExists_DeletesActivity)}";
using var context = TestApplicationDbContext.Create(dbName);
var cancellationToken = new CancellationToken();
var activity = Activity.Create("activity-title");
context.Activities.Add(activity);
await context.SaveChangesAsync(cancellationToken);
var handler = new DeleteActivityCommandHandler(context);
var request = new DeleteActivityCommand(1);
await handler.Handle(request, cancellationToken);
var activityFromDb = await context.Activities.FirstOrDefaultAsync(a => a.Id == 1);
Assert.Null(activityFromDb);
}
public async Task CannotDuplicateVehicleTestAsync()
{
//Arrange
//creating the fake vehicle that I'll try duplicate, tdb = test database
TestApplicationDbContext tdb = new TestApplicationDbContext();
Vehicle vehicleToNotBeDuplicated = new Vehicle
{
Description = "Vehicle with same description",
Title = "Nissan Micra",
Price = 1500,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
Vehicle vehicleToTryDuplicate = new Vehicle
{
Description = "Vehicle with same description",
Title = "Nissan Micra",
Price = 1250,
CubicCapicity = CC.cc1000,
FuelType = Fuel.Petrol
};
//adding the vehicles to the "fake" database
//I shouldn't be able to do this
tdb.Vehicles.Add(vehicleToTryDuplicate);
//creating a controller
VehicleController controller = new VehicleController(tdb);
//Act
//call controller searchIndexMethod
var result = await controller.Create(vehicleToNotBeDuplicated);
//var result = viewResult.ViewData.Model as IEnumerable<VehicleModel>;
//Assert
//we are checking that a view called Index is returned
Assert.IsInstanceOfType(result, typeof(ViewResult));
//view Result for the cannot create
}
