public async Task EnrollingUserTwoTimesToGroupTripWhichHeCreatedShoudThrowException()
{
var groupTripslist = new List <GroupTrip>
{
new GroupTrip
{
Id = 1,
HostId = "1",
FreeSeats = 3,
},
};
var mockTownRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(mockTownRepo.Object);
var mockUserGroupTripRepo = new Mock <IDeletableEntityRepository <UserGroupTrip> >();
var mockGroupTripRepo = new Mock <IDeletableEntityRepository <GroupTrip> >();
mockGroupTripRepo.Setup(x => x.All()).Returns(groupTripslist.AsQueryable());
mockGroupTripRepo.Setup(x => x.AddAsync(It.IsAny <GroupTrip>())).Callback((GroupTrip groupTrip) => groupTripslist.Add(groupTrip));
var service = new GroupTripsService(townService, mockGroupTripRepo.Object, mockUserGroupTripRepo.Object);
var exception = await Assert.ThrowsAsync <OperationCanceledException>(async() => await service.EnrollUser(1, "1"));
var message = "Не може да се запишете за излет създаден от вас!";
Assert.Equal(message, exception.Message);
}
public async Task EnrollingUserToGroupTripShoudIncreaseGuestsCount()
{
var groupTripslist = new List <GroupTrip>
{
new GroupTrip
{
Id = 1,
HostId = "2",
FreeSeats = 3,
},
};
var userGroupTripsList = new List <UserGroupTrip>();
var mockTownRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(mockTownRepo.Object);
var mockUserGroupTripRepo = new Mock <IDeletableEntityRepository <UserGroupTrip> >();
mockUserGroupTripRepo.Setup(x => x.AllAsNoTracking()).Returns(userGroupTripsList.AsQueryable());
var mockGroupTripRepo = new Mock <IDeletableEntityRepository <GroupTrip> >();
mockGroupTripRepo.Setup(x => x.All()).Returns(groupTripslist.AsQueryable());
mockGroupTripRepo.Setup(x => x.AddAsync(It.IsAny <GroupTrip>())).Callback((GroupTrip groupTrip) => groupTripslist.Add(groupTrip));
var service = new GroupTripsService(townService, mockGroupTripRepo.Object, mockUserGroupTripRepo.Object);
await service.EnrollUser(1, "3");
Assert.Single(groupTripslist.ElementAt(0).Guests);
}
public void CreatePlayerShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreatePlayer_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
Assert.NotNull(user.Player);
}
public void CreateRefereeShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreateReferee_Referees_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Haskovo");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Referee",
UserName = $"footeoReferee",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var refereesService = new RefereesService(dbContext, null, null);
var referee = new Referee
{
FullName = $"Footeo Referee"
};
refereesService.CreateReferee(user, referee);
Assert.NotNull(user.Referee);
}
public void SetLeagueStatusToCompletedAndReturnAllCompletedLeagues()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CompletedLeagues_Leagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
for (int i = 1; i <= 5; i++)
{
leaguesService.CreateLeague($"League{i}", $"Description{i}", DateTime.UtcNow.AddDays(i), DateTime.UtcNow.AddDays(i * i), "Sofia");
}
var leagues = dbContext.Leagues.ToList();
foreach (var league in leagues)
{
leaguesService.SetLeagueStatusToCompleted(league.Id);
}
var completedLeagues = leaguesService.AllCompletedLeagues <CompletedLeagueViewModel>().ToList();
var completedLeaguesCount = completedLeagues.Count;
var expectedCompletedLeaguesCount = 5;
Assert.AreEqual(expectedCompletedLeaguesCount, completedLeaguesCount);
}
public void AllFixturesByLeagueIdShouldReturnCorrectCount()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AllFixturesByLeague_Fixtures_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var fixturesService = new FixturesService(dbContext, leaguesService);
leaguesService.CreateLeague("League2", "Desc", DateTime.UtcNow, DateTime.UtcNow.AddMonths(2), "Varna");
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League2");
for (int i = 1; i <= 20; i++)
{
fixturesService.CreateFixture($"Matchday {i}", DateTime.UtcNow.AddDays(i + 7), league.Id);
}
var fixtures = fixturesService.AllFixtures <FixtureViewModel>(league.Id).ToList();
var expectedFixtures = 20;
Assert.AreEqual(expectedFixtures, fixtures.Count);
}
public void IsTeamInLeagueShouldReturnTrue()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "IsTeamInLeagueTrue_Teams_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Stara Zagora");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team", "TTT", user.UserName);
var team = dbContext.Teams.FirstOrDefault(n => n.Name == "Team");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow, DateTime.UtcNow.AddMonths(2), "Stara Zagora");
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League");
var teamLeague = new TeamLeague
{
Team = team,
League = league
};
dbContext.TeamsLeagues.Add(teamLeague);
dbContext.SaveChanges();
var isTeamInLeague = teamsService.IsTeamInLeague(team.Id);
Assert.True(isTeamInLeague);
}
public void InitializeTests()
{
this.dbContext = MockDbContext.GetDbContext();
var mapper = MockAutoMapper.GetMapper();
this.townsService = new TownsService(dbContext, mapper);
this.companiesService = new CompaniesService(dbContext, mapper, townsService);
}
private TownsService IntializeTownsService(SteuDbContext context)
{
var repository = new EfRepository <Town>(context);
MapperInitializer.InitializeMapper();
var service = new TownsService(repository);
return(service);
}
public async Task GetOrCreateTownByName_WithData_ShouldReturnTown()
{
var context = SteuDbContextInMemoryFactory.InitializeContext();
TownsService service = this.IntializeTownsService(context);
var repository = new EfRepository <Town>(context);
var actualResult = service.GetOrCreateTownByName("Sofia");
Assert.Equal("Sofia", actualResult.Name);
}
public void GetAllForSelectListShouldReturnAllFishspeciesAndOrderThemAlphabeticllyByName()
{
var fishSpeciesList = new List <FishSpecies>
{
new FishSpecies
{
Id = 1,
Name = "b",
},
new FishSpecies
{
Id = 2,
Name = "a",
},
new FishSpecies
{
Id = 3,
Name = "d",
},
new FishSpecies
{
Id = 4,
Name = "c",
},
};
var fishSpeciesRepo = new Mock <IDeletableEntityRepository <FishSpecies> >();
fishSpeciesRepo.Setup(x => x.AllAsNoTracking()).Returns(fishSpeciesList.AsQueryable());
var commentRepo = new Mock <IDeletableEntityRepository <Comment> >();
var commentService = new CommentService(commentRepo.Object);
var fishRepo = new Mock <IDeletableEntityRepository <Fish> >();
var fishService = new FishServices(fishRepo.Object);
var townRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(townRepo.Object);
var tripsRepo = new Mock <IDeletableEntityRepository <Trip> >();
var tripsService = new TripsService(commentService, tripsRepo.Object, fishService, townService);
var fishSpeciesService = new FishSpeciesService(fishSpeciesRepo.Object, tripsService);
var fishSpeciesFromService = fishSpeciesService.GetAllForSelectList();
Assert.Equal(fishSpeciesList.Count, fishSpeciesFromService.Count());
Assert.Collection(
fishSpeciesFromService,
item => Assert.Equal(fishSpeciesList.ElementAt(1).Name, item.Name),
item => Assert.Equal(fishSpeciesList.ElementAt(0).Name, item.Name),
item => Assert.Equal(fishSpeciesList.ElementAt(3).Name, item.Name),
item => Assert.Equal(fishSpeciesList.ElementAt(2).Name, item.Name));
}
void Reload()
{
Towns.Clear();
var townsService = new TownsService();
var townsList = townsService.GetAsync().Result;
foreach (var n in townsList)
{
Towns.Add(n.TownName);
}
}
public async Task CreatingGroupTripShouldIncreaseGroupTripsCount()
{
var groupTripslist = new List <GroupTrip>()
{
new GroupTrip
{
Id = 1,
},
new GroupTrip
{
Id = 2,
},
new GroupTrip
{
Id = 3,
},
};
var userGroupTripsList = new List <UserGroupTrip>();
var mockTownRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(mockTownRepo.Object);
var mockUserGroupTripRepo = new Mock <IDeletableEntityRepository <UserGroupTrip> >();
mockUserGroupTripRepo.Setup(x => x.AllAsNoTracking()).Returns(userGroupTripsList.AsQueryable());
var mockGroupTripRepo = new Mock <IDeletableEntityRepository <GroupTrip> >();
mockGroupTripRepo.Setup(x => x.All()).Returns(groupTripslist.AsQueryable());
mockGroupTripRepo.Setup(x => x.AddAsync(It.IsAny <GroupTrip>())).Callback((GroupTrip groupTrip) => groupTripslist.Add(groupTrip));
var service = new GroupTripsService(townService, mockGroupTripRepo.Object, mockUserGroupTripRepo.Object);
var groupTrip = new GroupTripCreateInputModel
{
WaterPoolName = "река Марица",
Description = "асдасдасдадс",
MeetingTime = DateTime.UtcNow.AddDays(1),
MeetingSpotLatitude = 1,
MeetingSpotLongtitude = 1,
FishingTime = DateTime.UtcNow.AddDays(2),
FishingSpotLatitude = 2,
FishingSpotLongtitude = 2,
FreeSeats = 2,
FishingMethodId = 3,
TargetFishSpeciesId = 5,
};
await service.CreateAsync(groupTrip, "1");
Assert.Equal(4, groupTripslist.Count());
}
public TownsServiceTests()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repo = new EfDeletableEntityRepository <Town>(new ApplicationDbContext(options.Options));
var service = new TownsService(repo);
AutoMapperConfig.RegisterMappings(
typeof(TownsIndexViewModel).GetTypeInfo().Assembly);
this.townsService = service;
this.repository = repo;
}
public void AllAwayMatchesByTeamIdShouldReturnNone()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AllAwayMatchesNone_Teams_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Ruse");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team4", "TTT", user.UserName);
var team = dbContext.Teams.FirstOrDefault(n => n.Name == "Team4");
var allAwayMatches = teamsService.AllAwayMatchesByTeamId(team.Id).ToList();
var allAwayMatchesCount = allAwayMatches.Count;
var expectedAwayMatchesCount = 0;
Assert.AreEqual(expectedAwayMatchesCount, allAwayMatchesCount);
}
public void TeamExistsByNameShouldReturnFalse()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "TeamExistsByNameFalse_Teams_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Sofia");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team", "TTT", user.UserName);
var team = dbContext.Teams.FirstOrDefault(n => n.Name == "Team");
var invalidTeamName = "Teeeeaaaam";
var teamExists = teamsService.TeamExistsByName(invalidTeamName);
Assert.False(teamExists);
}
public void GetTownByNameShouldReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetTownByName_Towns_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
townsService.CreateTown("Sofia");
var town = townsService.GetTownByName <Town>("Burgas");
Assert.Null(town);
}
public void GetTeamByIdShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetTeamById_Teams_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Plovdiv");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team1", "TTT", user.UserName);
var teamId = dbContext.Teams.FirstOrDefault(n => n.Name == "Team1").Id;
var team = teamsService.GetTeamById <TeamViewModel>(teamId);
Assert.NotNull(team);
}
public void PlayerHasATeamShouldReturnTrue()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "PlayerHasATeamTrue_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
var playerUser = dbContext.Players.FirstOrDefault(p => p.FullName == "Footeo Player");
playerUser.Team = new Team
{
Name = "Team",
Initials = "TTT"
};
dbContext.SaveChanges();
var playerHasATeam = playersService.PlayerHasATeam(user.UserName);
Assert.True(playerHasATeam);
}
public async Task GetAllItemsAsync()
{
this.towns.DeleteMany(_ => true);
this.towns.InsertOne(new Town {
Id = "1", Name = "Goslar"
});
this.towns.InsertOne(new Town {
Id = "2", Name = "Oker"
});
var service = new TownsService(this.Options);
var result = await service.GetAllItemsAsync().ConfigureAwait(false);
Assert.That(result.Count, Is.EqualTo(2));
Assert.That(result.First().Name, Is.EqualTo("Goslar"));
Assert.That(result.Skip(1).First().Name, Is.EqualTo("Oker"));
}
public void LeagueExistsByNameShouldReturnTrue()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "LeagueExistsByName_Leagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
leaguesService.CreateLeague("League", "Description", DateTime.UtcNow, DateTime.UtcNow.AddMonths(2), "Sofia");
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League");
var leagueExists = leaguesService.LeagueExistsByName(league.Name);
Assert.True(leagueExists);
}
public void GetLeagueByIdShouldReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetLeagueByName_Leagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
leaguesService.CreateLeague("League", "Description", DateTime.UtcNow, DateTime.UtcNow.AddMonths(2), "Sofia");
var invalidLeagueId = 2;
var league = leaguesService.GetLeagueById <League>(invalidLeagueId);
Assert.Null(league);
}
public void FieldExistsByNameShouldReturnFalse()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "FieldExists_Fields_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var fieldsService = new FieldsService(dbContext, townsService);
fieldsService.CreateField("Field", "Address", true, "Burgas");
var fieldNameForTest = "Field1";
var fieldExists = fieldsService.FieldExistsByName(fieldNameForTest);
Assert.False(fieldExists);
}
public async Task EnrollingUserTwoTimesToThesameTripShoudThrowAnError()
{
var groupTripslist = new List <GroupTrip>
{
new GroupTrip
{
Id = 1,
HostId = "2",
FreeSeats = 3,
},
};
var userGroupTripsList = new List <UserGroupTrip>
{
new UserGroupTrip
{
Id = 1,
GuestId = "1",
GroupTripId = 1,
},
};
var mockTownRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(mockTownRepo.Object);
var mockUserGroupTripRepo = new Mock <IDeletableEntityRepository <UserGroupTrip> >();
mockUserGroupTripRepo.Setup(x => x.AllAsNoTracking()).Returns(userGroupTripsList.AsQueryable());
var mockGroupTripRepo = new Mock <IDeletableEntityRepository <GroupTrip> >();
mockGroupTripRepo.Setup(x => x.All()).Returns(groupTripslist.AsQueryable());
mockGroupTripRepo.Setup(x => x.AddAsync(It.IsAny <GroupTrip>())).Callback((GroupTrip groupTrip) => groupTripslist.Add(groupTrip));
var service = new GroupTripsService(townService, mockGroupTripRepo.Object, mockUserGroupTripRepo.Object);
var exception = await Assert.ThrowsAsync <OperationCanceledException>(async() => await service.EnrollUser(1, "1"));
var message = "Вече сте записани за този излет!";
Assert.Equal(message, exception.Message);
}
public async Task GetAllByCountryIdAsync_ShouldReturnCorrectResult()
{
MapperInitializer.InitializeMapper();
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var townRepository = new EfDeletableEntityRepository <Town>(context);
var countryRepository = new EfDeletableEntityRepository <Country>(context);
var townsService = new TownsService(townRepository);
var seeder = new DbContextTestsSeeder();
await seeder.SeedCountriesAsync(context);
await seeder.SeedTownsAsync(context);
var countryId = await countryRepository.All()
.Select(c => c.Id)
.FirstOrDefaultAsync();
var result = await townsService.GetAllByCountryIdAsync(countryId);
Assert.True(result.ToList().Count == 1, ErrorMessage);
}
public void CreateTownShouldReturnCorrectTownsCount()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreateTown_Towns_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
for (int i = 1; i <= 50; i++)
{
townsService.CreateTown($"Town{i}");
}
var townsCount = dbContext.Towns.CountAsync().Result;
var expectedTownsCount = 50;
Assert.AreEqual(expectedTownsCount, townsCount);
}
public void GetAllCountShoudReturnTheCountOfAllFishSpeciesInTheRepo()
{
var fishSpeciesList = new List <FishSpecies>
{
new FishSpecies
{
Id = 1,
},
new FishSpecies
{
Id = 2,
},
new FishSpecies
{
Id = 3,
},
};
var fishSpeciesRepo = new Mock <IDeletableEntityRepository <FishSpecies> >();
fishSpeciesRepo.Setup(x => x.AllAsNoTracking()).Returns(fishSpeciesList.AsQueryable());
var commentRepo = new Mock <IDeletableEntityRepository <Comment> >();
var commentService = new CommentService(commentRepo.Object);
var fishRepo = new Mock <IDeletableEntityRepository <Fish> >();
var fishService = new FishServices(fishRepo.Object);
var townRepo = new Mock <IDeletableEntityRepository <Town> >();
var townService = new TownsService(townRepo.Object);
var tripsRepo = new Mock <IDeletableEntityRepository <Trip> >();
var tripsService = new TripsService(commentService, tripsRepo.Object, fishService, townService);
var fishSpeciesService = new FishSpeciesService(fishSpeciesRepo.Object, tripsService);
var fishSpeciesCount = fishSpeciesList.Count;
var fishSpeciesFountFromService = fishSpeciesService.GetAllCount();
Assert.Equal(fishSpeciesFountFromService, fishSpeciesCount);
}
public void SetLeagueStatusShouldReturnCompletedStatus()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "SetCompletedStatus_Leagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
leaguesService.CreateLeague($"LeagueC", $"Description", DateTime.UtcNow.AddDays(3), DateTime.UtcNow.AddMonths(3), "Varna");
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "LeagueC");
leaguesService.SetLeagueStatusToCompleted(league.Id);
var expectedLeagueStatus = "Completed";
Assert.AreEqual(expectedLeagueStatus, league.Status.ToString());
}
public void CreateLeagueShouldReturnCorrectCountOfLeagues()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreateLeague_Leagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
for (int i = 1; i <= 5; i++)
{
leaguesService.CreateLeague($"League{i}", $"Description{i}", DateTime.UtcNow.AddDays(i), DateTime.UtcNow.AddDays(i * i), "Sofia");
}
var leaguesCount = dbContext.Leagues.CountAsync().Result;
var expectedLeaguesCount = 5;
Assert.AreEqual(expectedLeaguesCount, leaguesCount);
}
public void CreateFieldShouldReturnCorrectCountOfFields()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "CreateField_Fields_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var fieldsService = new FieldsService(dbContext, townsService);
for (int i = 1; i <= 20; i++)
{
fieldsService.CreateField($"Field{i}", $"Address{i}", false, "Sofia");
}
var fieldsCount = dbContext.Fields.CountAsync().Result;
var expectedFieldsCount = 20;
Assert.AreEqual(expectedFieldsCount, fieldsCount);
}
