public void GivenASearchValue_WhenToStringIsCalled_ThenCorrectStringShouldBeReturned()
{
DateTimeSearchValue value = DateTimeSearchValue.Parse("2017");
Assert.NotNull(value);
Assert.Equal("2017", value.ToString());
}
public void GivenASearchValue_WhenToStringIsCalled_ThenCorrectStringShouldBeReturned()
{
DateTimeSearchValue value = DateTimeSearchValue.Parse("2017");
Assert.NotNull(value);
Assert.Equal("2017-01-01T00:00:00.0000000+00:00-2017-12-31T23:59:59.9999999+00:00", value.ToString());
}
public void GivenAValidString_WhenParsed_ThenCorrectSearchValueShouldBeReturned(string input, string expectedStart, string expectedEnd)
{
DateTimeSearchValue value = DateTimeSearchValue.Parse(input);
DateTimeOffset expectedStartDateTime = DateTimeOffset.Parse(expectedStart);
DateTimeOffset expectedEndDateTime = DateTimeOffset.Parse(expectedEnd);
Assert.NotNull(value);
Assert.Equal(expectedStartDateTime, value.Start);
Assert.Equal(expectedEndDateTime, value.End);
}
public void GivenAPartialDateTime_WhenInitialized_ThenCorrectStartDateTimeAndEndDateTimeShouldBeAssigned(string input, string start, string end)
{
PartialDateTime inputDateTime = PartialDateTime.Parse(input);
DateTimeOffset expectedStartDateTime = DateTimeOffset.Parse(start);
DateTimeOffset expectedEndDateTime = DateTimeOffset.Parse(end);
DateTimeSearchValue value = new DateTimeSearchValue(inputDateTime);
Assert.Equal(expectedStartDateTime, value.Start);
Assert.Equal(expectedEndDateTime, value.End);
}
public void GivenASearchValue_WhenCompareWithDateSearchValue_ThenCorrectResultIsReturned(string original, string given, int expectedMinResult, int expectedMaxResult)
{
DateTimeSearchValue originalValue = DateTimeSearchValue.Parse(original);
DateTimeSearchValue givenValue = DateTimeSearchValue.Parse(given);
int minResult = originalValue.CompareTo(givenValue, ComparisonRange.Min);
int maxResult = originalValue.CompareTo(givenValue, ComparisonRange.Max);
Assert.Equal(expectedMinResult, minResult);
Assert.Equal(expectedMaxResult, maxResult);
}
void ISearchValueVisitor.Visit(DateTimeSearchValue dateTime)
{
// By default, Json.NET will serialize date time object using format
// "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK". The 'F' format specifier
// will not display if the value is 0. For example, 2018-01-01T00:00:00.0000000+00:00
// is formatted as 2018-01-01T00:00:00+00:00 but 2018-01-01T00:00:00.9999999+00:00 is
// formatted as 2018-01-01T00:00:00.9999999+00:00. Because Cosmos DB only supports range index
// with string or number data type, the comparison does not work correctly in some cases.
// Output the date time using 'o' to make sure the fraction is always generated.
AddProperty(SearchValueConstants.DateTimeStartName, dateTime.Start.ToString("o", CultureInfo.InvariantCulture));
AddProperty(SearchValueConstants.DateTimeEndName, dateTime.End.ToString("o", CultureInfo.InvariantCulture));
}
public void GivenADateWithComparatorOfSingleBinaryOperator_WhenBuilt_ThenCorrectExpressionShouldBeCreated(string prefix, string dateTimeInput, FieldName fieldName, BinaryOperator binaryOperator, bool expectStartTimeValue)
{
var partialDateTime = PartialDateTime.Parse(dateTimeInput);
var dateTimeSearchValue = new DateTimeSearchValue(partialDateTime);
Validate(
CreateSearchParameter(SearchParamType.Date),
null,
prefix + dateTimeInput,
e => ValidateDateTimeBinaryOperatorExpression(
e,
fieldName,
binaryOperator,
expectStartTimeValue ? dateTimeSearchValue.Start : dateTimeSearchValue.End));
}
public void GivenADateWithNeComparator_WhenBuilt_ThenCorrectExpressionShouldBeCreated(string dateTimeInput)
{
var partialDateTime = PartialDateTime.Parse(dateTimeInput);
var dateTimeSearchValue = new DateTimeSearchValue(partialDateTime);
Validate(
CreateSearchParameter(SearchParamType.Date),
null,
"ne" + dateTimeInput,
e => ValidateMultiaryExpression(
e,
MultiaryOperator.Or,
e1 => ValidateDateTimeBinaryOperatorExpression(e1, FieldName.DateTimeStart, BinaryOperator.LessThan, dateTimeSearchValue.Start),
e2 => ValidateDateTimeBinaryOperatorExpression(e2, FieldName.DateTimeEnd, BinaryOperator.GreaterThan, dateTimeSearchValue.End)));
}
public void GivenADateTimeSearchValue_WhenGenerated_ThenCorrectJObjectShouldBeCreated()
{
var value = new DateTimeSearchValue(PartialDateTime.Parse("2000"), PartialDateTime.Parse("2001"));
var expectedValues = new[]
{
CreateTuple("st", "2000-01-01T00:00:00.0000000+00:00"),
CreateTuple("et", "2001-12-31T23:59:59.9999999+00:00"),
};
TestAndValidateOutput(
"date",
value,
expectedValues);
}
public void Visit(DateTimeSearchValue dateTime)
{
switch (_prefix)
{
case SearchValueConstants.SortLowValueFieldName:
AddProperty(_prefix, dateTime.Start.ToString("o", CultureInfo.InvariantCulture));
break;
case SearchValueConstants.SortHighValueFieldName:
AddProperty(_prefix, dateTime.End.ToString("o", CultureInfo.InvariantCulture));
break;
default:
throw new NotSupportedException();
}
}
public void GivenADateWithApComparator_WhenBuilt_ThenCorrectExpressionShouldBeCreated(string dateTimeInput, string expectedStartValue, string expectedEndValue)
{
using (Mock.Property(() => ClockResolver.UtcNowFunc, () => DateTimeOffset.Parse("2018-01-01T00:00Z")))
{
var partialDateTime = PartialDateTime.Parse(dateTimeInput);
var dateTimeSearchValue = new DateTimeSearchValue(partialDateTime);
Validate(
CreateSearchParameter(SearchParamType.Date),
null,
"ap" + dateTimeInput,
e => ValidateMultiaryExpression(
e,
MultiaryOperator.And,
e1 => ValidateDateTimeBinaryOperatorExpression(e1, FieldName.DateTimeStart, BinaryOperator.GreaterThanOrEqual, DateTimeOffset.Parse(expectedStartValue)),
e1 => ValidateDateTimeBinaryOperatorExpression(e1, FieldName.DateTimeEnd, BinaryOperator.LessThanOrEqual, DateTimeOffset.Parse(expectedEndValue))));
}
}
void ISearchValueVisitor.Visit(DateTimeSearchValue dateTime)
{
EnsureArg.IsNotNull(dateTime, nameof(dateTime));
if (_modifier != null)
{
ThrowModifierNotSupported();
}
// Based on spec here: http://hl7.org/fhir/STU3/search.html#prefix
switch (_comparator)
{
case SearchComparator.Eq:
_outputExpression = Expression.And(
Expression.GreaterThanOrEqual(FieldName.DateTimeStart, _componentIndex, dateTime.Start),
Expression.LessThanOrEqual(FieldName.DateTimeEnd, _componentIndex, dateTime.End));
break;
case SearchComparator.Ne:
_outputExpression = Expression.Or(
Expression.LessThan(FieldName.DateTimeStart, _componentIndex, dateTime.Start),
Expression.GreaterThan(FieldName.DateTimeEnd, _componentIndex, dateTime.End));
break;
case SearchComparator.Lt:
_outputExpression = Expression.LessThan(FieldName.DateTimeStart, _componentIndex, dateTime.Start);
break;
case SearchComparator.Gt:
_outputExpression = Expression.GreaterThan(FieldName.DateTimeEnd, _componentIndex, dateTime.End);
break;
case SearchComparator.Le:
_outputExpression = Expression.LessThanOrEqual(FieldName.DateTimeStart, _componentIndex, dateTime.End);
break;
case SearchComparator.Ge:
_outputExpression = Expression.GreaterThanOrEqual(FieldName.DateTimeEnd, _componentIndex, dateTime.Start);
break;
case SearchComparator.Sa:
_outputExpression = Expression.GreaterThan(FieldName.DateTimeStart, _componentIndex, dateTime.End);
break;
case SearchComparator.Eb:
_outputExpression = Expression.LessThan(FieldName.DateTimeEnd, _componentIndex, dateTime.Start);
break;
case SearchComparator.Ap:
var startTicks = dateTime.Start.UtcTicks;
var endTicks = dateTime.End.UtcTicks;
var differenceTicks = (long)((Clock.UtcNow.Ticks - Math.Max(startTicks, endTicks)) * ApproximateDateTimeRangeMultiplier);
var approximateStart = dateTime.Start.AddTicks(-differenceTicks);
var approximateEnd = dateTime.End.AddTicks(differenceTicks);
_outputExpression = Expression.And(
Expression.GreaterThanOrEqual(FieldName.DateTimeStart, _componentIndex, approximateStart),
Expression.LessThanOrEqual(FieldName.DateTimeEnd, _componentIndex, approximateEnd));
break;
default:
ThrowComparatorNotSupported();
break;
}
}
public void GivenAStringSearchValue_WhenCompareWithNull_ThenArgumentExceptionIsThrown()
{
DateTimeSearchValue value = DateTimeSearchValue.Parse("2020");
Assert.Throws <ArgumentException>(() => value.CompareTo(null, ComparisonRange.Max));
}
public void GivenASearchValue_WhenIsValidCompositeComponentIsCalled_ThenTrueShouldBeReturned()
{
var value = new DateTimeSearchValue(DateTimeOffset.Now);
Assert.True(value.IsValidAsCompositeComponent);
}
public void GivenAnInvalidString_WhenParsing_ThenExceptionShouldBeThrown(string s)
{
Assert.Throws <ArgumentException>(ParamNameS, () => DateTimeSearchValue.Parse(s));
}
public void GivenANullString_WhenParsing_ThenExceptionShouldBeThrown()
{
Assert.Throws <ArgumentNullException>(ParamNameS, () => DateTimeSearchValue.Parse(null));
}
