public async Task AddPlayerCommand_Can_Add_Player()
{
var dbContext = GetDbContext("AddPlayerCommand_Can_Add_Player");
using (dbContext)
{
var fakeRepo = new PlayerRepository(dbContext);
var fakeLogger = new Mock <ILogger <AddPlayerCommandHandler> >();
var handler = new AddPlayerCommandHandler(fakeRepo, GetMapper(), fakeLogger.Object);
var command = new AddPlayerCommand
{
Name = "FirstName",
Surname = "LastName",
Height = 1.98,
EmailAddress = "*****@*****.**"
};
var result = await handler.Handle(command, default);
Assert.False(result.Notifications.HasErrors());
Assert.Equal(command.Name, result.PlayerLookupModel.Name);
Assert.Equal(command.Surname, result.PlayerLookupModel.Surname);
Assert.Equal(command.Height, result.PlayerLookupModel.Height);
Assert.Equal(command.EmailAddress, result.PlayerLookupModel.EmailAddress);
}
}
public async Task Handle_GivenInvalidRequest_ShouldThrowTeamIsFullException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
for (int i = 0; i < 10; i++)
{
var player = new Player {
UserName = $"Placeholder{i}", Email = "foomail.bg",
};
this.dbContext.Add(player);
this.dbContext.PlayerTeams.Add(new PlayerTeam {
TeamId = 1, PlayerId = player.Id
});
this.dbContext.SaveChanges();
}
// Act & Assert
await Should.ThrowAsync <TeamIsFullException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public void SetUp()
{
_factory = new PlayersFactory();
var idGeneratorServiceStub = new Mock <IIdGenerator>();
idGeneratorServiceStub.Setup(id => id.NewGuid()).Returns(_factory.CreatedPlayerId);
var dateTimeServiceStub = new Mock <IDateTimeService>();
dateTimeServiceStub.Setup(dt => dt.UtcNow).Returns(new DateTime(2020, 12, 12));
var playersServiceStub = new Mock <IPlayersService>();
playersServiceStub.Setup(ps => ps.IsNicknameUniqueAsync(PlayersFactory.Player1NickName, null))
.Returns(Task.FromResult(false));
playersServiceStub.Setup(ps => ps.IsNicknameUniqueAsync(PlayersFactory.Player3NickName, null))
.Returns(Task.FromResult(true));
_sut = new AddPlayerCommandHandler(
Context,
new NullLogger <AddPlayerCommandHandler>(),
playersServiceStub.Object,
dateTimeServiceStub.Object,
idGeneratorServiceStub.Object);
}
public async Task Handle_GivenNullRequest_ShouldThrowArgumentNullException()
{
// Arrange
var sut = new AddPlayerCommandHandler(It.IsAny <IDeletableEntityRepository <Team> >(), It.IsAny <IDeletableEntityRepository <PlayerTeam> >());
// Act & Assert
await Should.ThrowAsync <ArgumentNullException>(sut.Handle(null, It.IsAny <CancellationToken>()));
}
public PlayerController(IPlayerRepository playerRepository, IRegistrationPlayerRepository registrationPlayerRepository, IAdminUnitOfWork adminUnitOfWork, AddPlayerCommandHandler addPlayerCommandHandler, UpdatePlayerCommandHandler updatePlayerCommandHandler)
{
this._playerRepository = playerRepository;
this._registrationPlayerRepository = registrationPlayerRepository;
this._adminUnitOfWork = adminUnitOfWork;
this._addPlayerCommandHandler = addPlayerCommandHandler;
this._updatePlayerCommandHandler = updatePlayerCommandHandler;
}
public async Task Handle_GivenInvalidRequest_ShouldThrowPlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo2"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act & Assert
await Should.ThrowAsync <PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public async Task Handle_GivenInvalidRequest_ShouldThrowNotFoundException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 313, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act & Assert
await Should.ThrowAsync <NotFoundException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public async Task Handle_GivenValidRequest_ShouldAddPlayerToTeam()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act
var affectedRows = await sut.Handle(command, It.IsAny <CancellationToken>());
// Assert
affectedRows.ShouldBeGreaterThan(0);
var isPlayerPresent = playerTeamsRepository.AllAsNoTracking().Any(x => x.PlayerId == "Foo5" && x.TeamId == 1);
isPlayerPresent.ShouldBe(true);
}
