public async Task Read_most_runouts_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 SqlServerBestPlayerTotalStatisticsDataSource(_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_runouts_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 SqlServerBestPlayerTotalStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object, Mock.Of <IPlayerDataSource>());
var result = await dataSource.ReadTotalPlayersWithRunOuts(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Matches
.Where(x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.PlayerInnings)
.Where(x => x.DismissalType == DismissalType.RunOut && x.DismissedBy != null)
.Select(x => x.DismissedBy.Player.PlayerId)
.Distinct()
.Count();
Assert.Equal(expected, result);
}
public async Task Read_player_innings_supports_filter_by_date()
{
var dateRangeGenerator = new DateRangeGenerator();
foreach (var player in _databaseFixture.TestData.PlayersWithMultipleIdentities)
{
var(fromDate, untilDate) = dateRangeGenerator.SelectDateRangeToTest(_databaseFixture.TestData.Matches);
var filter = new StatisticsFilter
{
FromDate = fromDate,
UntilDate = untilDate,
Paging = new Paging
{
PageSize = int.MaxValue
},
};
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 SqlServerPlayerPerformanceStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object);
var results = await dataSource.ReadPlayerInnings(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Matches.Where(x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.PlayerInnings)
.ToList();
Assert.Equal(expected.Count, results.Count());
foreach (var expectedInnings in expected)
{
Assert.NotNull(results.SingleOrDefault(x => x.Result.PlayerInningsId == expectedInnings.PlayerInningsId));
}
}
}
public async Task Read_total_players_with_batting_strike_rate_supports_filter_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.ReadTotalPlayersWithBattingStrikeRate(filter).ConfigureAwait(false);
var playerInnings = _databaseFixture.TestData.Matches
.Where(x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate)
.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_total_player_innings_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 SqlServerBestPerformanceInAMatchStatisticsDataSource(_databaseFixture.ConnectionFactory, queryBuilder.Object);
var result = await dataSource.ReadTotalPlayerInnings(filter).ConfigureAwait(false);
var expected = _databaseFixture.TestData.Matches.Where(x => x.StartTime >= filter.FromDate && x.StartTime <= filter.UntilDate)
.SelectMany(x => x.MatchInnings)
.SelectMany(x => x.PlayerInnings)
.Count(x => x.RunsScored.HasValue);
Assert.Equal(expected, result);
}
/// <summary>
/// A factory for returning the appropriate generator
/// </summary>
/// <param name="thisCustomAttribute">The decoration defining the generator</param>
/// <param name="thisPropInfo">The reflected values of the property</param>
/// <returns>IRandomGenerator</returns>
private IDataGenerator GetGenerator(CustomAttributeData thisCustomAttribute, PropertyInfo thisPropInfo)
{
IDataGenerator generator = null;
switch (thisCustomAttribute.AttributeType.Name)
{
case "IntegerGenerator":
generator = new IntegerGenerator();
break;
case "SingleGenerator":
generator = new SingleGenerator();
break;
case "SingleRangeGenerator":
generator = GetPropertyInfoAttribute <SingleRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DoubleRangeGenerator(Single.MinValue, Single.MaxValue);
}
break;
case "DoubleGenerator":
generator = new DoubleGenerator();
break;
case "NormallyDistributedDoubleGenerator":
generator = GetPropertyInfoAttribute <NormallyDistributedDoubleGenerator>(thisPropInfo);
if (generator == null)
{
generator = new NormallyDistributedDoubleGenerator(0, 1);
}
break;
case "DoubleRangeGenerator":
generator = GetPropertyInfoAttribute <DoubleRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DoubleRangeGenerator(double.MinValue, double.MaxValue);
}
break;
case "BoolGenerator":
generator = new BoolGenerator();
break;
case "IntegerRangeGenerator":
generator = GetPropertyInfoAttribute <IntegerRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new IntegerRangeGenerator(int.MinValue, int.MaxValue);
}
break;
case "StringRangeGenerator":
generator = GetPropertyInfoAttribute <StringRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new StringRangeGenerator(new string[] { "" });
}
break;
case "DateRangeGenerator":
generator = GetPropertyInfoAttribute <DateRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DateRangeGenerator(DateTime.MinValue, DateTime.MaxValue);
}
break;
case "StringFromFileGenerator":
string pathAsKey = thisCustomAttribute.ConstructorArguments.First().ToString();
// this is a cached generator, stored for the sake of not having to re-process the file
if (cacheGenerators.ContainsKey(pathAsKey))
{
generator = cacheGenerators[pathAsKey];
}
else
{
// process the gerneator
generator = GetPropertyInfoAttribute <StringFromFileGenerator>(thisPropInfo);
// add to a cache
cacheGenerators.Add(pathAsKey, generator);
}
if (generator == null)
{
generator = new StringRangeGenerator(new string[] { "" });
}
break;
case "IntegerSequenceGenerator":
var key = thisPropInfo.Name + "/" + thisCustomAttribute.AttributeType.Name;
if (cacheGenerators.ContainsKey(key))
{
generator = cacheGenerators[key];
}
else
{
// process the gerneator
generator = GetPropertyInfoAttribute <IntegerSequenceGenerator>(thisPropInfo);
// add to a cache
cacheGenerators.Add(key, generator);
}
if (generator == null)
{
generator = new IntegerSequenceGenerator();
}
break;
case "DecimalGenerator":
generator = new DecimalGenerator();
break;
case "DecimalRangeGenerator":
generator = GetPropertyInfoAttribute <DecimalRangeGenerator>(thisPropInfo);
if (generator == null)
{
generator = new DecimalRangeGenerator(double.MinValue, double.MaxValue);
}
break;
default:
break;
}
return(generator);
}
