public async Task AllAsyncShouldReturnAllGames()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.AddRangeAsync(
new Game { Id = 1 },
new Game { Id = 2 },
new Game { Id = 3 });
await dbContext.SaveChangesAsync();
var gameService = new GameService(dbContext, mapper);
// Act
var result = await gameService.AllAsync();
// Assert
result
.Should()
.Contain(g => g.Id == 1)
.And
.Contain(g => g.Id == 2)
.And
.Contain(g => g.Id == 3)
.And
.HaveCount(3);
}
public async Task AllToSelectListAsyncShouldReturnAllGamesToSelectListItems()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.AddRangeAsync(
new Game { Id = 1, Name = "Alpha" },
new Game { Id = 2, Name = "Beta" },
new Game { Id = 3, Name = "Gamma" });
await dbContext.SaveChangesAsync();
var gameService = new GameService(dbContext, mapper);
// Act
var result = await gameService.AllToSelectListAsync();
// Assert
result
.Should()
.Contain(r => r.Value == "1" && r.Text == "Alpha")
.And
.Contain(r => r.Value == "2" && r.Text == "Beta")
.And
.Contain(r => r.Value == "3" && r.Text == "Gamma")
.And
.HaveCount(3);
}
public async Task HasPlayerAsyncShouldReturnTrueIfTeamHasPlayer()
{
// Arrage
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.AddRangeAsync(
new Team
{
Id = 1,
Players = new List <PlayerTeam>
{
new PlayerTeam
{
PlayerId = "1",
TeamId = 1
}
}
});
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.HasPlayerAsync(1, "1");
// Assert
result
.Should()
.BeTrue();
}
public async Task AllAsyncShouldReturnAllUsers()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.Users
.AddRangeAsync(new User { Id = "1" }, new User { Id = "2" }, new User { Id = "3" });
await dbContext.SaveChangesAsync();
var adminUserService = new AdminUserService(dbContext, mapper);
// Act
var result = await adminUserService.AllAsync();
// Assert
result
.Should()
.Match(r => r.ElementAt(0).Id == "1" &&
r.ElementAt(1).Id == "2" &&
r.ElementAt(2).Id == "3")
.And
.HaveCount(3);
}
public async Task AllToSelectListAsyncShouldReturnAllTeamsInTournamentToSelectListItems()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.AddRangeAsync(
new Team
{
Id = 1,
Name = "Alpha",
Tournaments = new List <TeamTournament>
{
new TeamTournament {
TeamId = 1, TournamentId = 1
}
}
},
new Team { Id = 2, Name = "Beta" },
new Team
{
Id = 3,
Name = "Gamma",
Tournaments = new List <TeamTournament>
{
new TeamTournament {
TeamId = 3, TournamentId = 1
}
}
});
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.AllToSelectListAsync(1);
// Assert
result
.Should()
.Contain(r => r.Value == "1" && r.Text == "Alpha")
.And
.Contain(r => r.Value == "3" && r.Text == "Gamma")
.And
.HaveCount(2);
}
public async Task AllAsyncShouldReturnAllTeamsOrderedByTournamentsWonDescending()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.AddAsync(new Game { Id = 1, Name = "TestGame" });
await dbContext
.AddRangeAsync(
new Team
{
Id = 1,
Name = "Alpha",
Image = "test",
TournamentsWon = 0
},
new Team
{
Id = 2,
Name = "Beta",
Image = "test",
TournamentsWon = 5
},
new Team
{
Id = 3,
Name = "Gamma",
Image = "test",
TournamentsWon = 2
});
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.AllAsync();
// Assert
result
.Should()
.Match(t => t.ElementAt(0).Name == "Beta" &&
t.ElementAt(1).Name == "Gamma" &&
t.ElementAt(2).Name == "Alpha")
.And
.HaveCount(3);
}
public async Task ContainsAsyncShouldReturnFalseIfGameDoesNotExist()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
var gameService = new GameService(dbContext, mapper);
// Act
var result = await gameService.ContainsAsync("TestName");
// Assert
result
.Should()
.BeFalse();
}
public async Task AddAsyncShouldAddGameSuccessfully()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var adminUserService = new AdminGameService(dbContext);
// Act
await adminUserService.AddAsync("TestName", "TestDeveloper", "http://www.testimage.test");
// Assert
dbContext
.Games
.Should()
.Contain(
g => g.Name == "TestName" &&
g.Developer == "TestDeveloper" &&
g.Image == "http://www.testimage.test");
}
public async Task ContainsTagAsyncShouldReturnTrueIfTeamExist()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.Teams.AddAsync(new Team { Tag = "Test" });
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.ContainsTagAsync("Test");
// Assert
result
.Should()
.BeTrue();
}
public async Task ContainsAsyncShouldReturnTrueIfTournamentExists()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.Tournaments.AddAsync(new Tournament { Id = 1 });
await dbContext.SaveChangesAsync();
var tournamentService = new TournamentService(dbContext, mapper);
// Act
var result = await tournamentService.ContainsAsync(1);
// Assert
result
.Should()
.BeTrue();
}
public async Task CreateAsyncShouldSuccessfullyCreateTeam()
{
// Arrage
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
var teamService = new TeamService(dbContext, mapper);
// Act
await teamService.CreateAsync("TestName", "TEST", "http://testimage.test", "1");
// Assert
dbContext
.Teams
.Should()
.Contain(t => t.Name == "TestName" &&
t.Tag == "TEST" &&
t.Image == "http://testimage.test" &&
t.CaptainId == "1");
}
public async Task ContainsAsyncShouldReturnTrueIfGameExist()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.Games.AddAsync(new Game { Name = "TestName" });
await dbContext.SaveChangesAsync();
var gameService = new GameService(dbContext, mapper);
// Act
var result = await gameService.ContainsAsync("TestName");
// Assert
result
.Should()
.BeTrue();
}
public async Task HasEndedShouldReturnTrueIfTournamentHasEnded()
{
// Arange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.Tournaments.AddAsync(new Tournament { Id = 1, HasEnded = true });
await dbContext.SaveChangesAsync();
var tournamentService = new TournamentService(dbContext, mapper);
// Act
var result = tournamentService.HasEnded(1);
// Assert
result
.Should()
.BeTrue();
}
public async Task StartAsyncShouldSuccessfullyStartTournament()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.AddAsync(new Tournament { Id = 1, HasStarted = false });
await dbContext.SaveChangesAsync();
var moderatorTournamentService = new ModeratorTournamentService(dbContext, mapper);
// Act
await moderatorTournamentService.StartAsync(1);
// Assert
dbContext
.Tournaments
.Should()
.Contain(t => t.Id == 1 && t.HasStarted == true);
}
public async Task CreateAsyncShouldSuccessfullyCreateTournament()
{
// Arrange
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
var moderatorTournamentService = new ModeratorTournamentService(dbContext, mapper);
// Act
var startDate = DateTime.Now.AddDays(1);
await moderatorTournamentService.CreateAsync(
"TestTournament", PrizeType.Money, startDate, 1);
// Assert
dbContext
.Tournaments
.Should()
.Contain(g => g.Name == "TestTournament" &&
g.Prize == PrizeType.Money &&
g.StartDate == startDate &&
g.GameId == 1);
}
public async Task TotalAsyncShouldReturnTeamsCount()
{
// Arrage
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext.AddRangeAsync(
new Team { Id = 1 },
new Team { Id = 2 },
new Team { Id = 3 });
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.TotalAsync();
// Assert
result
.Should()
.Be(3);
}
public async Task DetailsAsyncShouldReturnTeamDetailsModel()
{
// Arrage
var dbContext = Testing.CreateDatabaseContext();
var mapper = Testing.CreateMapper();
await dbContext
.AddAsync(new Game { Id = 1, Name = "GameTest" });
await dbContext
.AddAsync(new User { Id = "1", UserName = "******" });
await dbContext
.AddRangeAsync(
new Team
{
Id = 1,
Name = "Team Test",
Image = "testimage.test",
Tag = "Test",
CaptainId = "1",
Players = new List <PlayerTeam>
{
new PlayerTeam
{
PlayerId = "1",
TeamId = 1
}
},
TournamentsWon = 0
});
await dbContext.SaveChangesAsync();
var teamService = new TeamService(dbContext, mapper);
// Act
var result = await teamService.DetailsAsync(1);
// Assert
result
.Id
.Should()
.Be(1);
result
.Name
.Should()
.Be("Team Test");
result
.Tag
.Should()
.Be("Test");
result
.Image
.Should()
.Be("testimage.test");
result.Captain
.Should()
.Be("Tester");
result
.Players
.Should()
.Contain(p => p.Equals("Tester"));
}
