public async Task Read_total_players_with_bowling_economy_supports_filter_by_season_id()
{
var filter = new StatisticsFilter {
Season = _databaseFixture.TestData.Competitions.First().Seasons.First()
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(filter)).Returns((" AND SeasonId = @SeasonId", new Dictionary <string, object> {
{ "SeasonId", _databaseFixture.TestData.Competitions.First().Seasons.First().SeasonId }
}));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithEconomyRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.Where(x => x.Season?.SeasonId == _databaseFixture.TestData.Competitions.First().Seasons.First().SeasonId)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.BowlingFigures);
var expected = bowlingFigures
.Where(x => x.Overs > 0 && x.RunsConceded.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_pages_results()
{
const int pageSize = 10;
var pageNumber = 1;
var remaining = _databaseFixture.TestData.Matches
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.BowlingFigures)
.Where(x => x.Wickets > 0 && x.Overs.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Distinct()
.Count();
while (remaining > 0)
{
var filter = new StatisticsFilter {
Paging = new Paging {
PageNumber = pageNumber, PageSize = pageSize
}
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var expected = pageSize > remaining ? remaining : pageSize;
Assert.Equal(expected, results.Count());
pageNumber++;
remaining -= pageSize;
}
}
public async Task Read_total_players_with_batting_strike_rate_supports_filter_by_competition_id()
{
var filter = new StatisticsFilter {
Competition = _databaseFixture.TestData.Competitions.First()
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(filter)).Returns((" AND CompetitionId = @CompetitionId", new Dictionary <string, object> {
{ "CompetitionId", _databaseFixture.TestData.Competitions.First().CompetitionId }
}));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithBattingStrikeRate(filter).ConfigureAwait(false);
var playerInnings = _databaseFixture.TestData.Matches
.Where(x => x.Season?.Competition?.CompetitionId == _databaseFixture.TestData.Competitions.First().CompetitionId)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.PlayerInnings);
var expected = playerInnings
.Where(x => x.RunsScored.HasValue && x.BallsFaced.HasValue)
.Select(x => x.Batter.Player.PlayerId)
.Where(x => playerInnings.Any(pi => pi.Batter.Player.PlayerId == x && pi.RunsScored.HasValue && pi.BallsFaced.HasValue && pi.BallsFaced > 0))
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_sorts_by_lowest_average_first()
{
var filter = new StatisticsFilter {
Paging = new Paging {
PageSize = int.MaxValue
}
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var previousAverage = decimal.MinValue;
foreach (var result in results)
{
Assert.True(result.Result.Average >= previousAverage);
previousAverage = result.Result.Average.Value;
}
}
public async Task Read_best_bowling_strike_rate_supports_statistics_filtered_by_date()
{
var dateRangeGenerator = new DateRangeGenerator();
var(fromDate, untilDate) = dateRangeGenerator.SelectDateRangeToTest(_databaseFixture.TestData.Matches);
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
FromDate = fromDate,
UntilDate = untilDate
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND MatchStartTime >= @FromDate AND MatchStartTime <= @UntilDate", new Dictionary <string, object> {
{ "FromDate", filter.FromDate }, { "UntilDate", filter.UntilDate }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
await ActAndAssertStatistics(filter, dataSource, x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate, x => true, x => true).ConfigureAwait(false);
}
public async Task Read_total_players_with_bowling_strike_rate_supports_filter_by_club_id()
{
var filter = new StatisticsFilter {
Club = _databaseFixture.TestData.TeamWithFullDetails.Club
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(filter)).Returns((" AND ClubId = @ClubId", new Dictionary <string, object> {
{ "ClubId", _databaseFixture.TestData.TeamWithFullDetails.Club.ClubId }
}));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithBowlingStrikeRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.Where(x => x.Teams.Select(t => t.Team.TeamId).Contains(_databaseFixture.TestData.TeamWithFullDetails.TeamId.Value))
.SelectMany(x => x.MatchInnings)
.Where(i => i.BowlingTeam.Team.TeamId == _databaseFixture.TestData.TeamWithFullDetails.TeamId.Value)
.SelectMany(x => x.BowlingFigures);
var expected = bowlingFigures
.Where(x => x.Wickets > 0 && x.Overs.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_supports_minimum_qualifying_innings()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
MinimumQualifyingInnings = 5
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches.SelectMany(m => m.MatchInnings).SelectMany(mi => mi.BowlingFigures);
var expected = _databaseFixture.TestData.Players.Where(x =>
bowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.Overs.HasValue && bf.Wickets > 0)
&&
bowlingFigures.Count(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.Overs.HasValue) >= filter.MinimumQualifyingInnings);
Assert.Equal(expected.Count(), results.Count());
foreach (var player in expected)
{
Assert.NotNull(results.SingleOrDefault(x => x.Result.Player.PlayerId == player.PlayerId));
}
}
public async Task Read_total_players_with_bowling_strike_rate_supports_minimum_qualifying_innings()
{
var filter = new StatisticsFilter {
MinimumQualifyingInnings = 5
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithBowlingStrikeRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.BowlingFigures);
var expected = bowlingFigures
.Where(x => x.Wickets > 0 && x.Overs.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Where(x =>
bowlingFigures.Count(bf => bf.Bowler.Player.PlayerId == x && bf.Overs.HasValue) >= filter.MinimumQualifyingInnings)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_returns_player()
{
var filter = new StatisticsFilter {
Paging = new Paging {
PageSize = int.MaxValue
}
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Players.Where(x => _databaseFixture.TestData.Matches
.SelectMany(m => m.MatchInnings)
.SelectMany(mi => mi.BowlingFigures)
.Where(pi => pi.Bowler.Player.PlayerId == x.PlayerId)
.Any(pi => pi.Wickets > 0 && pi.Overs.HasValue));
foreach (var player in expected)
{
var result = results.SingleOrDefault(x => x.Result.Player.PlayerId == player.PlayerId);
Assert.NotNull(result);
Assert.Equal(player.PlayerRoute, result.Result.Player.PlayerRoute);
Assert.Equal(player.PlayerName(), result.Result.Player.PlayerName());
}
}
public async Task Read_best_batting_strike_rate_supports_filter_by_season_id()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
Season = _databaseFixture.TestData.Competitions.First().Seasons.First()
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND SeasonId = @SeasonId", new Dictionary <string, object> {
{ "SeasonId", _databaseFixture.TestData.Competitions.First().Seasons.First().SeasonId }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBattingStrikeRate(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Players.Where(x => _databaseFixture.TestData.Matches
.Where(x => x.Season?.SeasonId == _databaseFixture.TestData.Competitions.First().Seasons.First().SeasonId)
.SelectMany(m => m.MatchInnings)
.SelectMany(mi => mi.PlayerInnings)
.Any(pi => pi.Batter.Player.PlayerId == x.PlayerId && pi.RunsScored.HasValue && pi.BallsFaced.HasValue && pi.BallsFaced.Value > 0)
);
Assert.Equal(expected.Count(), results.Count());
foreach (var player in expected)
{
Assert.NotNull(results.SingleOrDefault(x => x.Result.Player.PlayerId == player.PlayerId));
}
}
public async Task Read_total_players_with_bowling_strike_rate_supports_filter_by_date()
{
var dateRangeGenerator = new DateRangeGenerator();
var(fromDate, untilDate) = dateRangeGenerator.SelectDateRangeToTest(_databaseFixture.TestData.Matches);
var filter = new StatisticsFilter {
FromDate = fromDate, UntilDate = untilDate
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(filter)).Returns((" AND MatchStartTime >= @FromDate AND MatchStartTime <= @UntilDate", new Dictionary <string, object> {
{ "FromDate", filter.FromDate }, { "UntilDate", filter.UntilDate }
}));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithBowlingStrikeRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.Where(x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.BowlingFigures);
var expected = bowlingFigures
.Where(x => x.Wickets > 0 && x.Overs.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_returns_statistics()
{
var filter = new StatisticsFilter {
Paging = new Paging {
PageSize = int.MaxValue
}
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
await ActAndAssertStatistics(filter, dataSource, x => true, x => true, x => true).ConfigureAwait(false);
}
public async Task Read_total_players_with_bowling_economy_supports_no_filter()
{
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((string.Empty, new Dictionary <string, object>()));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithEconomyRate(null).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Matches
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.BowlingFigures)
.Where(x => x.Overs > 0 && x.RunsConceded.HasValue)
.Select(x => x.Bowler.Player.PlayerId)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_best_bowling_strike_rate_supports_statistics_filtered_by_season_id()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
Season = _databaseFixture.TestData.Competitions.First().Seasons.First()
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND SeasonId = @SeasonId", new Dictionary <string, object> {
{ "SeasonId", _databaseFixture.TestData.Competitions.First().Seasons.First().SeasonId }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
await ActAndAssertStatistics(filter, dataSource, x => x.Season?.SeasonId == filter.Season.SeasonId, x => true, x => true).ConfigureAwait(false);
}
public async Task Read_best_bowling_strike_rate_supports_filter_by_team_id()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
Team = _databaseFixture.TestData.TeamWithFullDetails
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND TeamId = @TeamId", new Dictionary <string, object> {
{ "TeamId", _databaseFixture.TestData.TeamWithFullDetails.TeamId }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.Where(x => x.Teams.Select(t => t.Team.TeamId).Contains(_databaseFixture.TestData.TeamWithFullDetails.TeamId.Value))
.SelectMany(m => m.MatchInnings)
.Where(i => i.BowlingTeam.Team.TeamId == _databaseFixture.TestData.TeamWithFullDetails.TeamId.Value)
.SelectMany(mi => mi.BowlingFigures);
var expected = _databaseFixture.TestData.Players.Where(x =>
bowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.Overs.HasValue && bf.Wickets > 0)
&&
bowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.Overs.HasValue));
Assert.Equal(expected.Count(), results.Count());
foreach (var player in expected)
{
Assert.NotNull(results.SingleOrDefault(x => x.Result.Player.PlayerId == player.PlayerId));
}
}
public async Task Read_best_bowling_strike_rate_supports_statistics_filtered_by_team_id()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
Team = _databaseFixture.TestData.TeamWithFullDetails
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND TeamId = @TeamId", new Dictionary <string, object> {
{ "TeamId", _databaseFixture.TestData.TeamWithFullDetails.TeamId }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
await ActAndAssertStatistics(filter, dataSource, x => true, i => i.BattingTeam.Team.TeamId == _databaseFixture.TestData.TeamWithFullDetails.TeamId.Value, i => i.BowlingTeam.Team.TeamId == _databaseFixture.TestData.TeamWithFullDetails.TeamId.Value).ConfigureAwait(false);
}
public async Task Read_best_bowling_economy_supports_filter_by_match_location_id()
{
var filter = new StatisticsFilter
{
Paging = new Paging
{
PageSize = int.MaxValue
},
MatchLocation = _databaseFixture.TestData.MatchLocations.First()
};
var queryBuilder = new Mock <IStatisticsQueryBuilder>();
queryBuilder.Setup(x => x.BuildWhereClause(It.IsAny <StatisticsFilter>())).Returns((" AND MatchLocationId = @MatchLocationId", new Dictionary <string, object> {
{ "MatchLocationId", _databaseFixture.TestData.MatchLocations.First().MatchLocationId }
}));
var playerDataSource = new Mock <IPlayerDataSource>();
playerDataSource.Setup(x => x.ReadPlayers(It.IsAny <PlayerFilter>())).Returns(Task.FromResult(_databaseFixture.TestData.Players));
var dataSource = new SqlServerBestPlayerAverageStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, playerDataSource.Object);
var results = await dataSource.ReadBestEconomyRate(It.IsAny <StatisticsFilter>()).ConfigureAwait(false);
var bowlingFigures = _databaseFixture.TestData.Matches
.Where(x => x.MatchLocation?.MatchLocationId == _databaseFixture.TestData.MatchLocations.First().MatchLocationId)
.SelectMany(m => m.MatchInnings)
.SelectMany(mi => mi.BowlingFigures);
var expected = _databaseFixture.TestData.Players.Where(x =>
bowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.RunsConceded.HasValue && bf.Overs > 0)
&&
bowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == x.PlayerId && bf.RunsConceded.HasValue));
Assert.Equal(expected.Count(), results.Count());
foreach (var player in expected)
{
Assert.NotNull(results.SingleOrDefault(x => x.Result.Player.PlayerId == player.PlayerId));
}
}
private async Task ActAndAssertStatistics(StatisticsFilter filter, SqlServerBestPlayerAverageStatisticsDataSource dataSource, Func <Stoolball.Matches.Match, bool> matchFilter, Func <MatchInnings, bool> battingInningsFilter, Func <MatchInnings, bool> bowlingInningsFilter)
{
var oversHelper = new OversHelper();
var results = await dataSource.ReadBestBowlingStrikeRate(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Players.Select(p => new BestStatistic
{
Player = p,
TotalMatches = (int)_databaseFixture.TestData.Matches
.Where(matchFilter)
.Count(m => m.MatchInnings.Where(battingInningsFilter).Any(mi => mi.PlayerInnings.Any(pi => pi.Batter.Player.PlayerId == p.PlayerId)) ||
m.MatchInnings.Where(bowlingInningsFilter).Any(mi =>
mi.PlayerInnings.Any(pi => pi.DismissedBy?.Player.PlayerId == p.PlayerId || pi.Bowler?.Player.PlayerId == p.PlayerId) ||
mi.OversBowled.Any(o => o.Bowler.Player.PlayerId == p.PlayerId) ||
mi.BowlingFigures.Any(bf => bf.Bowler.Player.PlayerId == p.PlayerId)
) ||
m.Awards.Any(aw => aw.PlayerIdentity.Player.PlayerId == p.PlayerId)),
TotalInnings = (int)_databaseFixture.TestData.Matches
.Where(matchFilter)
.SelectMany(m => m.MatchInnings)
.Where(bowlingInningsFilter)
.SelectMany(mi => mi.BowlingFigures)
.Count(pi => pi.Bowler.Player.PlayerId == p.PlayerId && pi.Overs.HasValue),
Average = (_databaseFixture.TestData.Matches
.Where(matchFilter)
.SelectMany(m => m.MatchInnings)
.Where(bowlingInningsFilter)
.SelectMany(mi => mi.BowlingFigures)
.Any(bf => bf.Bowler.Player.PlayerId == p.PlayerId && bf.Wickets > 0 && bf.Overs.HasValue) ?
((decimal)_databaseFixture.TestData.Matches
.Where(matchFilter)
.SelectMany(m => m.MatchInnings)
.Where(bowlingInningsFilter)
.SelectMany(mi => mi.BowlingFigures)
.Where(bf => bf.Bowler.Player.PlayerId == p.PlayerId && bf.Overs.HasValue)
.Sum(bf => oversHelper.OversToBallsBowled(bf.Overs.Value)))
/
_databaseFixture.TestData.Matches
.Where(matchFilter)
.SelectMany(m => m.MatchInnings)
.Where(bowlingInningsFilter)
.SelectMany(mi => mi.BowlingFigures)
.Where(bf => bf.Bowler.Player.PlayerId == p.PlayerId && bf.Overs.HasValue)
.Sum(bf => bf.Wickets)
: (decimal?)null)
}).Where(x => x.Average.HasValue);
foreach (var player in expected)
{
var result = results.SingleOrDefault(x => x.Result.Player.PlayerId == player.Player.PlayerId);
Assert.NotNull(result);
Assert.Equal(player.TotalMatches, result.Result.TotalMatches);
Assert.Equal(player.TotalInnings, result.Result.TotalInnings);
if (player.Average.HasValue)
{
Assert.Equal(player.Average.Value.AccurateToTwoDecimalPlaces(), result.Result.Average.Value.AccurateToTwoDecimalPlaces());
}
else
{
Assert.Null(result.Result.Average);
}
}
}
