public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is null || value is string)
{
var text = ((string)value)?.Trim() ?? string.Empty;
if (text.Length == 0)
{
return(DuodecimDate.MinValue);
}
DateTimeFormatInfo formatInfo = null;
if (culture != null)
{
formatInfo = (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
}
if (formatInfo != null)
{
return(DuodecimDate.Parse(text, formatInfo));
}
return(DuodecimDate.Parse(text));
}
return(base.ConvertFrom(context, culture, value));
}
public void GreaterThanOrEqualOperator_WhenSameYearAndDate1MonthGreaterThanDate2Month_ReturnTrue()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2018, 5);
// Act
var comparisonResult = date1 >= date2;
// Assert
Assert.True(comparisonResult);
}
public void AddYears_WhenAddingYears_ReturnNewInstance()
{
// Arrange
var date = new DuodecimDate(2018, 6);
// Act
var newDate = date.AddYears(1);
// Assert
Assert.False(Equals(date, newDate));
}
public void Parse_WhenParsingInvalidCultureDateFormat_ThrowFormatException(string dateString)
{
// Arrange
var expectedExceptionMessage = $"Cannot parse value '{dateString}' to a valid {nameof(DuodecimDate)}.";
var cultureInfo = NorwegianCulture;
// Act
var exception = Record.Exception(() => DuodecimDate.Parse(dateString, cultureInfo));
// Assert
exception.Verify <FormatException>(expectedExceptionMessage);
}
public void SubtractMonths_WhenSubtractingMonths_ReturnNewInstance()
{
// Arrange
var date = new DuodecimDate(2018, 6);
// Act
var newDate = date.SubtractMonths(1);
// Assert
Assert.False(Equals(date, newDate));
}
public void LessThanOrEqual_WhenSameYearAndSameMonth_ReturnTrue()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2018, 6);
// Act
var comparisonResult = date1 <= date2;
// Assert
Assert.True(comparisonResult);
}
public void LessThanOrEqualOperator_WhenDate1YearGreaterThanDate1Year_ReturnFalse()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2017, 6);
// Act
var comparisonResult = date1 <= date2;
// Assert
Assert.False(comparisonResult);
}
public void EqualOperator_WhenSameYearAndSameMonth_ReturnFalse()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2018, 6);
// Act
var comparisonResult = date1 != date2;
// Assert
Assert.False(comparisonResult);
}
public void NotEqualOperator_WhenDifferentYearAndSameMonth_ReturnTrue()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2019, 6);
// Act
var comparisonResult = date1 != date2;
// Assert
Assert.True(comparisonResult);
}
public void LessThanOrEqual_WhenSameYearAndDate1MonthGreaterThanDate2Month_ReturnFalse()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2018, 5);
// Act
var comparisonResult = date1 <= date2;
// Assert
Assert.False(comparisonResult);
}
public void GreaterThanOperator_WhenDate1YearGreaterThanDate1Year_ReturnTrue()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2017, 6);
// Act
var comparisonResult = date1 > date2;
// Assert
Assert.True(comparisonResult);
}
public void Compare_WhenSameYearsAndMonthLessThanOtherMonth_ReturnMinus1()
{
// Arrange
const int expectedCompareResult = -1;
var date = new DuodecimDate(2018, 1);
var otherDate = new DuodecimDate(2018, 2);
// Act
var actualCompareResult = date.CompareTo(otherDate);
// Assert
Assert.Equal(expectedCompareResult, actualCompareResult);
}
public void Equals_WhenObjectAndObjectIsNull_ReturnFalse()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
object nullObject = null;
// Act
// ReSharper disable once ExpressionIsAlwaysNull
var areEqual = date1.Equals(nullObject);
// Assert
Assert.False(areEqual);
}
public void DuodecimDate_WhenConstructedWithArguments_PropertiesSet()
{
// Arrange
const int expectedYear = 2018;
const int expectedMonth = 10;
// Act
var date = new DuodecimDate(expectedYear, expectedMonth);
// Assert
Assert.Equal(expectedYear, date.Year);
Assert.Equal(expectedMonth, date.Month);
}
public void GetHashCode_WhenTwoObjectHasSameProperties_ReturnSameHashCode()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var date2 = new DuodecimDate(2018, 6);
// Act
var hash1 = date1.GetHashCode();
var hash2 = date2.GetHashCode();
// Assert
Assert.Equal(hash1, hash2);
}
public void Parse_WhenParsingDateAndTimeWithOffsetWithUsCulture_ReturnExpectedDuodecimDate(
string dateString, int expectedYear, int expectedMonth)
{
// Arrange
var expectedDuodecimDate = new DuodecimDate(expectedYear, expectedMonth);
var cultureInfo = UnitedStatesCulture;
// Act
var parsedDuodecimDate = DuodecimDate.Parse(dateString, cultureInfo);
// Assert
Assert.Equal(expectedDuodecimDate, parsedDuodecimDate);
}
public void Equals_WhenSomeRandomObjectThatIsNotDuodecimDate_ReturnFalse()
{
// Arrange
var date1 = new DuodecimDate(2018, 6);
var randomObject = new SomeRandomType();
// Act
// ReSharper disable once SuspiciousTypeConversion.Global
var areEqual = date1.Equals(randomObject);
// Assert
Assert.False(areEqual);
}
public void Compare_WhenYearGreaterThanOtherYear_Return1()
{
// Arrange
const int expectedCompareResult = 1;
var date = new DuodecimDate(2018, 1);
var otherDate = new DuodecimDate(2017, 12);
// Act
var actualCompareResult = date.CompareTo(otherDate);
// Assert
Assert.Equal(expectedCompareResult, actualCompareResult);
}
public void Compare_WhenBothPointToSameReference_Return0()
{
// Arrange
const int expectedCompareResult = 0;
var date = new DuodecimDate(2018, 6);
var otherDate = date;
// Act
var actualCompareResult = date.CompareTo(otherDate);
// Assert
Assert.Equal(expectedCompareResult, actualCompareResult);
}
Parse_WhenParsingDateAndTimeWithOffsetAndNorwegianCultureAndDateTimeStyle_ReturnExpectedDuodecimDate(
string dateString, int expectedYear, int expectedMonth)
{
// Arrange
var expectedDuodecimDate = new DuodecimDate(expectedYear, expectedMonth);
var cultureInfo = NorwegianCulture;
const DateTimeStyles dateTimeStyles = DateTimeStyles.None;
// Act
var parsedDuodecimDate = DuodecimDate.Parse(dateString, cultureInfo, dateTimeStyles);
// Assert
Assert.Equal(expectedDuodecimDate, parsedDuodecimDate);
}
public void LessThanOperator_WhenDate1YearLessThanDate1Year_ReturnTrue()
{
// Arrange
var date1 = new DuodecimDate(2017, 6);
var date2 = new DuodecimDate(2018, 6);
var eq = date1.Equals(date2);
// Act
var comparisonResult = date1 < date2;
// Assert
Assert.True(comparisonResult);
}
public void SubtractYears_WhenSubtractingNegativeYears_ThrowArgumentOutOfRangeException()
{
// Arrange
const int yearsToSubtract = -1;
var date = new DuodecimDate(2018, 6);
// Act
var exception = Record.Exception(() => date.SubtractYears(yearsToSubtract));
// Assert
exception.Verify <ArgumentOutOfRangeException>(string.Format(ExpectedYearOrMonthIsNegativeExceptionMessage,
"years"));
}
Parse_WhenParsingCommonDateTimeFormatsAndParsingWithoutCulture_AssumeCurrentCultureAndReturnExpectedDuodecimDate(
int year, int month, int day)
{
// Arrange
var dateTime = new DateTime(year, month, day);
var dateTimeAsString = dateTime.ToString(DateTimeFormatInfo.CurrentInfo);
var expectedDuodecimDate = new DuodecimDate(year, month);
// Act
var parsedDuodecimDate = DuodecimDate.Parse(dateTimeAsString);
// Assert
Assert.Equal(expectedDuodecimDate, parsedDuodecimDate);
}
public ActionResult <IEnumerable <MonthlySale> > Get([Required] DuodecimDate fromDuodecimDate,
[Required] DuodecimDate toDuodecimDate)
{
var salesForYearFromDatabase = MonthlySales
.Where(monthlySale => monthlySale.Year >= fromDuodecimDate.Year)
.Where(monthlySale => monthlySale.Year <= toDuodecimDate.Year)
.ToList();
var matchingSales = salesForYearFromDatabase
.Where(monthlySale => monthlySale.DuodecimDate >= fromDuodecimDate)
.Where(monthlySale => monthlySale.DuodecimDate <= toDuodecimDate);
return(Ok(matchingSales));
}
public void ConvertTo_WhenSourceTypeStringAndValueDuodecimDate_ReturnExpectedValue()
{
// Arrange
var destinationType = typeof(string);
var dateToConvert = new DuodecimDate(2018, 11);
var exectedString = dateToConvert.ToString();
var converter = new DuodecimDateConverter();
// Act
var actualString = converter.ConvertTo(null, null, dateToConvert, destinationType);
// Assert
Assert.Equal(exectedString, actualString);
}
public void SubtractYears_WhenSubtractingYears_YearsSubtracted()
{
// Arrange
const int startYear = 2018;
const int yearsToSubtract = 13;
const int expectedYear = startYear - yearsToSubtract;
var date = new DuodecimDate(startYear, 6);
// Act
var newDate = date.SubtractYears(yearsToSubtract);
// Assert
Assert.Equal(expectedYear, newDate.Year);
}
public void AddMonths_WhenAddingMonths_MonthsAdded()
{
// Arrange
const int startMonth = 1;
const int monthsToAdd = 2;
const int expectedMonth = startMonth + monthsToAdd;
var date = new DuodecimDate(2018, startMonth);
// Act
var newDate = date.AddMonths(monthsToAdd);
// Assert
Assert.Equal(expectedMonth, newDate.Month);
}
public void SubtractMonths_WhenSubtractingMonths_MonthsSubtracted()
{
// Arrange
const int startMonth = 8;
const int monthsToSubtract = 3;
const int expectedMonth = startMonth - monthsToSubtract;
var date = new DuodecimDate(2018, startMonth);
// Act
var newDate = date.SubtractMonths(monthsToSubtract);
// Assert
Assert.Equal(expectedMonth, newDate.Month);
}
public void AddYears_WhenAddingYears_YearsAdded()
{
// Arrange
const int startYear = 2018;
const int yearsToAdd = 13;
const int expectedYear = startYear + yearsToAdd;
var date = new DuodecimDate(startYear, 6);
// Act
var newDate = date.AddYears(yearsToAdd);
// Assert
Assert.Equal(expectedYear, newDate.Year);
}
public void Equals_WhenDuodecimDateObjectAndYearMonthSame_ReturnTrue()
{
// Arrange
const int year = 2018;
const int month = 11;
var date1 = new DuodecimDate(year, month);
var date2 = new DuodecimDate(year, month);
// Act
var areEqual = date1.Equals((object)date2);
// Assert
Assert.True(areEqual);
}
