private static IReadOnlyList <Datapoint <T> > AddDatapointsWithGapLikely <T>(
IReadOnlyList <Datapoint <T> > datapoints,
ReportingPeriod reportingPeriod,
TimeComparison timeComparison)
{
var result = new List <Datapoint <T> >();
var adjacentReportingPeriod = GetAdjacentBoundedReportingPeriod(reportingPeriod, timeComparison);
// Most likely will result in a gap in the timeseries and also possibly datapoints in different granularity.
var adjacentDatapoints = adjacentReportingPeriod
.GetUnitsWithin()
.Select(_ => _.ToReportingPeriod())
.Select(_ => new Datapoint <T>(_, A.Dummy <T>()))
.ToList();
if (timeComparison == TimeComparison.After)
{
result.AddRange(datapoints);
result.AddRange(adjacentDatapoints);
}
else
{
result.AddRange(adjacentDatapoints);
result.AddRange(datapoints);
}
return(result);
}
private static ReportingPeriod GetAdjacentBoundedReportingPeriod(
ReportingPeriod reportingPeriod,
TimeComparison timeComparison)
{
ReportingPeriod result;
if (timeComparison == TimeComparison.After)
{
result = A.Dummy <ReportingPeriod>()
.Whose(_ => (!_.HasComponentWithUnboundedGranularity()) &&
(_.GetUnitOfTimeKind() == reportingPeriod.GetUnitOfTimeKind()) &&
(_.Start.ToMostGranular().Start > reportingPeriod.End.ToMostGranular().End));
}
else if (timeComparison == TimeComparison.Before)
{
result = A.Dummy <ReportingPeriod>()
.Whose(_ => (!_.HasComponentWithUnboundedGranularity()) &&
(_.GetUnitOfTimeKind() == reportingPeriod.GetUnitOfTimeKind()) &&
(_.End.ToMostGranular().End < reportingPeriod.Start.ToMostGranular().Start));
}
else
{
throw new NotSupportedException(Invariant($"This {nameof(TimeComparison)} is not supported: {timeComparison}."));
}
return(result);
}
void AssertIntervalEqualTo(
DateTime basePoint, DateTime target,
int years = 0, int months = 0, int days = 0, int hours = 0, int minutes = 0, int seconds = 0,
int milliseconds = 0, bool negative = false
)
{
CalendarTimeSpan diff = TimeComparison.CalendarDifference(basePoint, target);
Assert.Equal(
new CalendarTimeSpan(years, months, days, hours, minutes, seconds, milliseconds, negative),
diff
);
}
public static int Compare(DateTime a, DateTime b, TimeComparison mode)
{
switch (mode)
{
case TimeComparison.JustDate:
return(DateTime.Compare(a.Date, b.Date));
case TimeComparison.JustTime:
return(TimeSpan.Compare(a.TimeOfDay, b.TimeOfDay));
default:
return(DateTime.Compare(a, b));
}
}
public void After_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime min, TimeComparison timeComparison, bool expectedIsValid)
{
Tester.TestSingleMemberRule <DateTime?>(
m => m.After(min, timeComparison),
memberValue,
expectedIsValid,
Phrases.Keys.Times.After,
new[]
{
Arg.Time("min", min),
Arg.Enum("timeComparison", timeComparison)
});
}
public void Between_Should_CollectError_When_TimeComparisonSet(DateTime min, DateTime model, DateTime max, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule(
model,
m => m.Between(min, max, timeComparison),
shouldBeValid,
MessageKey.Times.Between,
Arg.Time("min", min),
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison));
}
public void NotEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime value, TimeComparison timeComparison, bool expectedIsValid)
{
Tester.TestSingleMemberRule <DateTime?>(
m => m.NotEqualTo(value, timeComparison),
memberValue,
expectedIsValid,
Phrases.Keys.Times.NotEqualTo,
new[]
{
Arg.Time("value", value),
Arg.Enum("timeComparison", timeComparison)
});
}
public static IMemberSpecificationBuilder <TModel, DateTime?> Before <TModel>(this IMemberSpecificationBuilder <TModel, DateTime?> @this, DateTime max, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.AsNullable(m => m.Before(max, timeComparison)));
}
public void Before_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTime model, DateTime max, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule <DateTime?>(
model,
m => m.Before(max, timeComparison),
shouldBeValid,
MessageKey.Times.Before,
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison));
}
public void Before_Should_CollectError_When_TimeComparisonSet(DateTime memberValue, DateTime max, TimeComparison timeComparison, bool expectedIsValid)
{
Tester.TestSingleMemberRule(
m => m.Before(max, timeComparison),
memberValue,
expectedIsValid,
Phrases.Keys.Times.Before,
new[]
{
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison)
});
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> BetweenOrEqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset min, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.Valid(m => (TimeComparer.Compare(m, min, timeComparison) >= 0) && (TimeComparer.Compare(m, max, timeComparison) <= 0), Phrases.Keys.Times.BetweenOrEqualTo, new[] { Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison) }));
}
public void NotEqualTo_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset model, DateTimeOffset value, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule <DateTimeOffset?>(
model,
m => m.NotEqualTo(value, timeComparison),
shouldBeValid,
MessageKey.Times.NotEqualTo,
Arg.Time("value", value),
Arg.Enum("timeComparison", timeComparison));
}
public void BeforeOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTimeOffset model, DateTimeOffset max, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule(
model,
m => m.BeforeOrEqualTo(max, timeComparison),
shouldBeValid,
MessageKey.Times.BeforeOrEqualTo,
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison));
}
public static IRuleOut <DateTime?> BetweenOrEqualTo(this IRuleIn <DateTime?> @this, DateTime min, DateTime max, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, min, timeComparison) >= 0 && TimeComparer.Compare(m.Value, max, timeComparison) <= 0, MessageKey.Times.BetweenOrEqualTo, Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public static IRuleOut <DateTime> EqualTo(this IRuleIn <DateTime> @this, DateTime value, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m, value, timeComparison) == 0, MessageKey.Times.EqualTo, Arg.Time(nameof(value), value), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public static IRuleOut <DateTime> Between(this IRuleIn <DateTime> @this, DateTime min, DateTime max, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m, min, timeComparison) > 0 && TimeComparer.Compare(m, max, timeComparison) < 0, MessageKey.Times.Between, Arg.Time(nameof(min), min), Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public static IRuleOut <DateTime> BeforeOrEqualTo(this IRuleIn <DateTime> @this, DateTime max, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m, max, timeComparison) <= 0, MessageKey.Times.BeforeOrEqualTo, Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public static IRuleOut <DateTime> AfterOrEqualTo(this IRuleIn <DateTime> @this, DateTime min, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m, min, timeComparison) >= 0, MessageKey.Times.AfterOrEqualTo, Arg.Time(nameof(min), min), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public void BetweenOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime min, DateTime memberValue, DateTime max, TimeComparison timeComparison, bool expectedIsValid)
{
Tester.TestSingleMemberRule <DateTime?>(
m => m.BetweenOrEqualTo(min, max, timeComparison),
memberValue,
expectedIsValid,
Phrases.Keys.Times.BetweenOrEqualTo,
new[]
{
Arg.Time("min", min),
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison)
});
}
public static IRuleOut <DateTimeOffset?> After(this IRuleIn <DateTimeOffset?> @this, DateTimeOffset min, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, min, timeComparison) > 0, MessageKey.Times.After, Arg.Time(nameof(min), min), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> After <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset min, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.AsNullable(m => m.After(min, timeComparison)));
}
public static IRuleOut <DateTimeOffset?> Before(this IRuleIn <DateTimeOffset?> @this, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All)
{
return(@this.RuleTemplate(m => TimeComparer.Compare(m.Value, max, timeComparison) < 0, MessageKey.Times.Before, Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison)));
}
public void After_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset model, DateTimeOffset min, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule <DateTimeOffset?>(
model,
m => m.After(min, timeComparison),
shouldBeValid,
MessageKey.Times.After,
Arg.Time("min", min),
Arg.Enum("timeComparison", timeComparison));
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> BetweenOrEqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset min, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.AsNullable(m => m.BetweenOrEqualTo(min, max, timeComparison)));
}
public void BetweenOrEqualTo_Should_CollectError_When_TimeComparisonSet_FromNullable(DateTimeOffset min, DateTimeOffset model, DateTimeOffset max, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule <DateTimeOffset?>(
model,
m => m.BetweenOrEqualTo(min, max, timeComparison),
shouldBeValid,
MessageKey.Times.BetweenOrEqualTo,
Arg.Time("min", min),
Arg.Time("max", max),
Arg.Enum("timeComparison", timeComparison));
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset?> EqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset?> @this, DateTimeOffset value, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.AsNullable(m => m.EqualTo(value, timeComparison)));
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> Before <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset max, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.Valid(m => TimeComparer.Compare(m, max, timeComparison) < 0, Phrases.Keys.Times.Before, new[] { Arg.Time(nameof(max), max), Arg.Enum(nameof(timeComparison), timeComparison) }));
}
public void EqualTo_Should_CollectError_When_TimeComparisonSet(DateTime model, DateTime value, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule(
model,
m => m.EqualTo(value, timeComparison),
shouldBeValid,
MessageKey.Times.EqualTo,
Arg.Time("value", value),
Arg.Enum("timeComparison", timeComparison));
}
public static IMemberSpecificationBuilder <TModel, DateTimeOffset> EqualTo <TModel>(this IMemberSpecificationBuilder <TModel, DateTimeOffset> @this, DateTimeOffset value, TimeComparison timeComparison = TimeComparison.All)
where TModel : class
{
return(@this.Valid(m => TimeComparer.Compare(m, value, timeComparison) == 0, Phrases.Keys.Times.EqualTo, new[] { Arg.Time(nameof(value), value), Arg.Enum(nameof(timeComparison), timeComparison) }));
}
public void AfterOrEqualTo_Should_CollectError_When_TimeComparisonSet(DateTime model, DateTime min, TimeComparison timeComparison, bool shouldBeValid)
{
Tester.TestSingleRule(
model,
m => m.AfterOrEqualTo(min, timeComparison),
shouldBeValid,
MessageKey.Times.AfterOrEqualTo,
Arg.Time("min", min),
Arg.Enum("timeComparison", timeComparison));
}
