public void GetMatchesTest_Check_Score()
{
//arrange
var matches = new List <Matches>
{
new Matches
{
Id = 4,
Location = "Jeziorany",
Address = "ul. Marii Konopnickiej",
Year = 2018,
MatchesScore = new List <MatchesScore>
{
new MatchesScore {
TeamId = 1, HalfTimeScore = 2, FullTimeScore = 6
},
new MatchesScore {
TeamId = 2, HalfTimeScore = 1, FullTimeScore = 2
}
}
},
new Matches
{
Id = 5,
Location = "Olsztyn",
Address = "ul. Jagielończyka",
Year = 2012,
MatchesScore = new List <MatchesScore>
{
new MatchesScore {
TeamId = 1, HalfTimeScore = 3, FullTimeScore = 2
},
new MatchesScore {
TeamId = 2, HalfTimeScore = 2, FullTimeScore = 4
}
}
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Matches> >();
mockSet.As <IQueryable <Matches> >().Setup(m => m.Provider).Returns(matches.Provider);
mockSet.As <IQueryable <Matches> >().Setup(m => m.Expression).Returns(matches.Expression);
mockSet.As <IQueryable <Matches> >().Setup(m => m.ElementType).Returns(matches.ElementType);
mockSet.As <IQueryable <Matches> >().Setup(m => m.GetEnumerator()).Returns(matches.GetEnumerator());
var mockContext = new Mock <MulderContext>();
mockContext.Setup(c => c.Matches).Returns(mockSet.Object);
///act
var service = new MatchesService(mockContext.Object);
var result = service.GetMatches();
//assert
Assert.IsTrue(result.Count == 2);
Assert.IsTrue(result[0].ScoreInfo[0].FullTimeScore == 6);
Assert.IsTrue(result[0].ScoreInfo[1].FullTimeScore == 2);
Assert.IsTrue(result[1].ScoreInfo[0].FullTimeScore == 2);
Assert.IsTrue(result[1].ScoreInfo[1].FullTimeScore == 4);
}
public async Task Ok_Success()
{
var service = new MatchesService(_repository.Object, null, _mapper);
await service.BulkAddMatches(MockedMatches().ToList());
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Once);
}
public async Task Ok_Success()
{
var service = new MatchesService(_repository.Object, null, _mapper);
await service.AddMatch(MockedMatch());
_repository.Verify(x => x.AddAsync(It.IsAny <DataRepository.DataEntities.Match>()), Times.Once);
}
async Task ExecuteLoadMatchesCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Matches.Clear();
var matches = await MatchesService.GetMatches();
foreach (var match in matches)
{
Matches.Add(match);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public void RepositoryError_ThrowException()
{
_repository.Setup(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >())).ThrowsAsync(new DataException());
var service = new MatchesService(_repository.Object, null, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.BulkAddMatches(MockedMatches().ToList()));
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Once);
}
public void RepositoryError_ThrowException()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ThrowsAsync(new DataException());
var service = new MatchesService(_repository.Object, null, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.GetSeasonRoundMatchesAsync(Year, Season, Round));
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
}
public void GetMatchesError_ThrowException()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ThrowsAsync(new DataException());
var service = new MatchesService(_repository.Object, null, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.DeleteAllMatchesFromSeasonRoundAsync(Year, Season, Round));
_repository.Verify(x => x.DeleteMatchesAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Never);
}
public void RepositoryGetError_ThrowException()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ThrowsAsync(new DataException());
var service = new MatchesService(_repository.Object, null, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.SetRoundResults(Year, Season, Round, MockedResults().ToList()));
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Never);
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
}
public async Task Ok_Success()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()))
.ReturnsAsync(MockedMatches().ToList());
var service = new MatchesService(_repository.Object, null, _mapper);
await service.SetRoundResults(Year, Season, Round, MockedResults().ToList());
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Once);
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
}
public async Task Ok_Success()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ReturnsAsync(MockedMatches().ToList());
var service = new MatchesService(_repository.Object, null, _mapper);
var result = await service.GetSeasonRoundMatchesAsync(Year, Season, Round);
Assert.NotNull(result);
Assert.IsInstanceOf <IEnumerable <BusinessEntities.Match> >(result);
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
}
public async Task Ok_Success()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ReturnsAsync(MockedMatches().ToList());
var service = new MatchesService(_repository.Object, _configService.Object, _mapper);
await service.ResetAllMatchesFromSeasonAsync(Year, Season);
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Exactly(10));
_configService.Verify(x => x.GetConfig(It.IsAny <short>(), It.IsAny <byte>()), Times.Once);
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Exactly(10));
}
public void GetMatchesError_ThrowException()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>())).ThrowsAsync(new DataException());
var service = new MatchesService(_repository.Object, _configService.Object, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.ResetAllMatchesFromSeasonAsync(Year, Season));
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
_configService.Verify(x => x.GetConfig(It.IsAny <short>(), It.IsAny <byte>()), Times.Once);
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Never);
}
public ActionResult Index()
{
var matches = MatchesService.GetMatchesInTwentyFourHours();
var viewModelMatches = new HashSet <Match>();
foreach (var match in matches)
{
var bets = new HashSet <Bet>();
foreach (var bet in match.Bets)
{
var newBet = new Bet()
{
Name = bet.Name,
IsLive = bet.IsLive
};
var odds = new HashSet <Odd>();
foreach (var odd in bet.Odds)
{
odds.Add(new Odd()
{
Name = odd.Name,
Value = odd.Value,
SpecialBetValue = odd.SpecialBetValue
});
}
newBet.Odds = odds;
bets.Add(newBet);
}
viewModelMatches.Add(new Match()
{
SportName = match.Event.Sport.Name,
EventName = match.Event.Name,
Name = match.Name,
MatchType = match.MatchType,
StartDate = match.StartDate,
Bets = bets
});
}
return(this.View(viewModelMatches));
}
public void RepositoryMissingMatch_ThrowException()
{
_repository.Setup(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()))
.ReturnsAsync(MockedMatches().ToList());
var wrongMatch = MockedResults().ToList();
wrongMatch[2].HomeTeamId = 99;
var service = new MatchesService(_repository.Object, null, _mapper);
Assert.ThrowsAsync <DataException>(async() => await service.SetRoundResults(Year, Season, Round, wrongMatch));
_repository.Verify(x => x.BatchUpsertAsync(It.IsAny <IEnumerable <DataRepository.DataEntities.Match> >()), Times.Never);
_repository.Verify(x => x.GetMatchesAsync(It.IsAny <short>(), It.IsAny <byte>(), It.IsAny <byte>()), Times.Once);
}
public void GetMatchTest_Check_Player_Name()
{
//arrange
var matches = new List <Matches>
{
new Matches
{
Id = 5,
MatchesScore = new List <MatchesScore>
{
new MatchesScore {
TeamId = 1, HalfTimeScore = 3, FullTimeScore = 2
},
new MatchesScore {
TeamId = 2, HalfTimeScore = 2, FullTimeScore = 4
}
},
MatchesLineUp = new List <MatchesLineUp>
{
new MatchesLineUp {
Player = new Players {
NickName = "Sopel"
},
PlayersScore = new List <PlayersScore>()
}
},
MatchesSpectators = new List <MatchesSpectators>(),
}
}.AsQueryable();
var mockSet = new Mock <DbSet <Matches> >();
mockSet.As <IQueryable <Matches> >().Setup(m => m.Provider).Returns(matches.Provider);
mockSet.As <IQueryable <Matches> >().Setup(m => m.Expression).Returns(matches.Expression);
mockSet.As <IQueryable <Matches> >().Setup(m => m.ElementType).Returns(matches.ElementType);
mockSet.As <IQueryable <Matches> >().Setup(m => m.GetEnumerator()).Returns(matches.GetEnumerator());
var mockContext = new Mock <MulderContext>();
mockContext.Setup(c => c.Matches).Returns(mockSet.Object);
///act
var service = new MatchesService(mockContext.Object);
var result = service.GetMatch(5);
//assert
Assert.IsTrue(result.Players[0].PlayerNick == "Sopel");
}
public MatchesServiceTests()
{
_sut = new MatchesService(_mapperMock.Object, _unitOfWorkMock.Object);
}
public void SimulateMethodWorkCorrectly()
{
var matchList = new List <Match>
{
new Match
{
Id = 1,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 2,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 3,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 2,
LeagueId = 1,
},
};
var teamsList = new List <Team>()
{
new Team
{
Id = 1,
Name = "Real Madrid",
},
new Team
{
Id = 2,
Name = "Barcelona",
},
};
var matchRepo = new Mock <IDeletableEntityRepository <Match> >();
matchRepo.Setup(r => r.All()).Returns(matchList.AsQueryable());
var leagueRepo = new Mock <IDeletableEntityRepository <League> >();
var userRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
var teamRepo = new Mock <IDeletableEntityRepository <Team> >();
teamRepo.Setup(x => x.All()).Returns(teamsList.AsQueryable());
var playerRepo = new Mock <IDeletableEntityRepository <Player> >();
var predictionRepo = new Mock <IDeletableEntityRepository <Prediction> >();
var service = new MatchesService(matchRepo.Object, teamRepo.Object, leagueRepo.Object, playerRepo.Object, predictionRepo.Object);
}
public void GetAllMethodReturnCorrectDataSetProperties()
{
var list = new List <Match>
{
new Match
{
Id = 1,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 2,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 3,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 2,
LeagueId = 1,
},
}.AsQueryable <Match>();
var leagues = new List <League>()
{
new League
{
Id = 1,
Name = "English",
Country = "England",
Matches = list.ToList(),
},
}.AsQueryable <League>();
var teamsList = new List <Team>()
{
new Team
{
Id = 1,
Name = "Real Madrid",
},
new Team
{
Id = 2,
Name = "Barcelona",
},
};
var matchRepo = new Mock <IDeletableEntityRepository <Match> >();
matchRepo.Setup(r => r.All()).Returns(list);
var leagueRepo = new Mock <IDeletableEntityRepository <League> >();
leagueRepo.Setup(r => r.All()).Returns(leagues);
var userRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
var teamRepo = new Mock <IDeletableEntityRepository <Team> >();
teamRepo.Setup(x => x.All()).Returns(teamsList.AsQueryable());
var playerRepo = new Mock <IDeletableEntityRepository <Player> >();
var predictionRepo = new Mock <IDeletableEntityRepository <Prediction> >();
var service = new MatchesService(matchRepo.Object, teamRepo.Object, leagueRepo.Object, playerRepo.Object, predictionRepo.Object);
var leaguesList = service.GetAll(1);
var matches = leaguesList.Select(m => m.Matches).FirstOrDefault();
var league = leaguesList.FirstOrDefault();
var leagueId = league.LeagueId;
var leagueName = league.LeagueName;
var matchId = league.Matches.Select(x => x.Id).FirstOrDefault();
var homeGoals = league.Matches.Select(x => x.HomeGoals).FirstOrDefault();
var awayGoals = league.Matches.Select(x => x.AwayGoals).FirstOrDefault();
var gameWeekId = league.Matches.Select(x => x.GameweekId).FirstOrDefault();
var homeName = league.Matches.Select(x => x.HomeName).FirstOrDefault();
var awayName = league.Matches.Select(x => x.AwayName).FirstOrDefault();
Assert.Equal(leaguesList.Count(), leagues.Count());
Assert.Equal(matches.Count(), list.Where(m => m.GameweekId == 1).Count());
Assert.Equal(1, leagueId);
Assert.Equal("English", leagueName);
leagueRepo.Verify(x => x.All(), Times.Once);
Assert.Equal(1, matchId);
Assert.Equal(3, homeGoals);
Assert.Equal(1, awayGoals);
Assert.Equal(1, gameWeekId);
Assert.Equal("Real Madrid", homeName);
Assert.Equal("Barcelona", awayName);
}
public void GetAllMethodByUserReturnIsMatchPredicted()
{
var list = new List <Match>
{
new Match
{
Id = 1,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 2,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 1,
LeagueId = 1,
},
new Match
{
Id = 3,
HomeTeamId = 1,
AwayTeamId = 2,
HomeGoals = 3,
AwayGoals = 1,
ResultType = FootballPredictor.Data.Models.Enums.BetType.Home,
GameweekId = 2,
LeagueId = 1,
},
}.AsQueryable <Match>();
var leagues = new List <League>()
{
new League
{
Id = 1,
Name = "English",
Country = "England",
Matches = list.ToList(),
},
}.AsQueryable <League>();
var user = new ApplicationUser
{
Id = "abc",
UserName = "******",
};
var predictions = new List <Prediction>()
{
new Prediction
{
Id = 1,
HomeTeamGoals = 2,
AwayTeamGoals = 1,
Bet = FootballPredictor.Data.Models.Enums.BetType.Home,
MatchId = 1,
UserId = user.Id,
Description = "dadadadadadadadadadadadada",
GameweekId = 1,
},
new Prediction
{
Id = 2,
HomeTeamGoals = 2,
AwayTeamGoals = 1,
Bet = FootballPredictor.Data.Models.Enums.BetType.Home,
MatchId = 1,
UserId = "cfe",
Description = "dadadadadadadadadadadadada",
GameweekId = 1,
},
};
user.Predictions.Add(predictions[0]);
var matchRepo = new Mock <IDeletableEntityRepository <Match> >();
matchRepo.Setup(r => r.All()).Returns(list);
var leagueRepo = new Mock <IDeletableEntityRepository <League> >();
leagueRepo.Setup(r => r.All()).Returns(leagues);
var userRepo = new Mock <IDeletableEntityRepository <ApplicationUser> >();
var teamRepo = new Mock <IDeletableEntityRepository <Team> >();
var playerRepo = new Mock <IDeletableEntityRepository <Player> >();
var predictionRepo = new Mock <IDeletableEntityRepository <Prediction> >();
predictionRepo.Setup(r => r.All()).Returns(predictions.AsQueryable());
var service = new MatchesService(matchRepo.Object, teamRepo.Object, leagueRepo.Object, playerRepo.Object, predictionRepo.Object);
var leaguesModels = service.GetAll(user.Id, 1);
var match = leaguesModels.Select(x => x.Matches).FirstOrDefault().FirstOrDefault();
var pred = predictions[0];
Assert.Equal(leaguesModels.Count(), leagues.Count());
Assert.Equal(user.Id, pred.UserId);
Assert.Equal(false, match.PredictionCreated);
predictionRepo.Verify(x => x.All(), Times.Once);
}
public void RefereeAttendToMatchShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AttendToMatch_Referees_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Burgas");
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 userHT = 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(userHT);
dbContext.SaveChanges();
var userAT = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer2",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(userAT);
dbContext.SaveChanges();
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.RemoveFromRoleAsync(userHT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.RemoveFromRoleAsync(userAT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var fieldsService = new FieldsService(dbContext, townsService);
var leaguesService = new LeaguesService(dbContext, townsService);
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
var teamLeaguesService = new TeamLeaguesService(dbContext, teamsService, leaguesService);
var fixturesService = new FixturesService(dbContext, leaguesService);
var matchesService = new MatchesService(dbContext, fixturesService, teamsService);
var refereesService = new RefereesService(dbContext, matchesService, teamLeaguesService);
var referee = new Referee
{
FullName = $"Footeo Referee"
};
refereesService.CreateReferee(user, referee);
townsService.CreateTown("Sofia");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow, DateTime.UtcNow.AddMonths(3), "Sofia");
teamsService.CreateTeam("Home Team", "HT", userHT.UserName);
teamsService.CreateTeam("Away Team", "AT", userAT.UserName);
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League");
teamLeaguesService.JoinLeague(userHT.UserName, league.Id);
teamLeaguesService.JoinLeague(userAT.UserName, league.Id);
fixturesService.CreateFixture("Matchday", DateTime.UtcNow.AddDays(7), league.Id);
var fixture = dbContext.Fixtures.FirstOrDefault(n => n.Name == "Matchday");
fieldsService.CreateField("Field", "Address", true, "Sofia");
var field = dbContext.Fields.FirstOrDefault(n => n.Name == "Field");
matchesService.CreateMatch(userHT.Player.Team.Id, userAT.Player.Team.Id, field.Id, fixture.Id);
var match = dbContext.Matches.FirstOrDefault();
refereesService.AttendAMatch(user.UserName, match.Id);
Assert.NotNull(match.Referee);
}
public MatchController(MatchesService MatchService, TicketsService ticketsService)
{
_matchService = MatchService;
_ticketsService = ticketsService;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="matchesService"></param>
public MatchesController(MatchesService <MatchesViewModel, Match> matchesService)
{
_matchesService = matchesService;
}
