DateRange DDD Model

DateRange.cs

public struct DateRange
{
    public DateRange(DateTime start, DateTime end)
        : this()
    {
        if (start > end)
        {
            throw new ArgumentException("Start date time cannot be after end date time");
        }
        Start = start;
        End = end;
    }

    public DateTime Start { get; private set; }

    public DateTime End { get; private set; }

    public static bool operator ==(DateRange range1, DateRange range2)
    {
        return range1.Start == range2.Start && range1.End == range2.End;
    }

    public static bool operator !=(DateRange range1, DateRange range2)
    {
        return !(range1 == range2);
    }

    public static DateRange FromDays(DateTime start, int days)
    {
        if (days < 0)
        {
            return new DateRange(start.AddDays(days), start);
        }
        return new DateRange(start, start.AddDays(days));
    }

    public bool InRange(DateTime dateTime)
    {
        return dateTime >= Start && dateTime <= End;
    }
}

DateRangeTests.cs

public class DateRangeTests
{
  [TestFixture]
  public class when_instantiating_date_ranges
  {
      [Test]
      public void then_should_set_start_date_given_start_date()
      {
          // Arrange // Act
          var start = DateTime.Parse("1/1/2015");
          var dateRange = new DateRange(start, DateTime.Parse("12/31/2015"));

          // Assert
          Assert.That(dateRange.Start, Is.EqualTo(start));
      }
      [Test]
      public void then_should_set_end_date_given_and_end_date()
      {
          // Arrange // Act
          var end = DateTime.Parse("1/1/2015");
          var dateRange = new DateRange(new DateTime(), end);

          // Assert
          Assert.That(dateRange.End, Is.EqualTo(end));
      }

      [Test]
      public void then_should_throw_argument_exception_given_start_date_after_end_date()
      {
          // Arrange // Act // Assert
          Assert.Throws<ArgumentException>(() => new DateRange(DateTime.Parse("12/31/2015"), DateTime.Parse("12/1/2015")));
      }
  }

  [TestFixture]
  public class when_creating_new_range_with_start_date_and_positive_days
  {
      [Test]
      public void then_should_create_range_with_end_date_1_1_2016_given_start_date_1_1_2015_and_365_days()
      {
          // Arrange // Act
          var range = DateRange.FromDays(DateTime.Parse("1/1/2015"), 365);

          // Assert
          Assert.That(range.End, Is.EqualTo(DateTime.Parse("1/1/2016")));
      }
  }
  [TestFixture]
  public class when_creating_new_range_with_start_date_and_negative_days
  {
      [Test]
      public void then_should_create_range_with_start_date_1_1_2014_given_start_date_1_1_2015_and_negative_365_days()
      {
          // Arrange // Act
          var range = DateRange.FromDays(DateTime.Parse("1/1/2015"), -365);

          // Assert
          Assert.That(range.Start, Is.EqualTo(DateTime.Parse("1/1/2014")));
      }
      [Test]
      public void then_should_create_range_with_end_date_equal_to_start_date_given_start_date_1_1_2015_and_negative_365_days()
      {
          // Arrange // Act
          var start = DateTime.Parse("1/1/2015");
          var range = DateRange.FromDays(start, -365);

          // Assert
          Assert.That(range.End, Is.EqualTo(start));
      }
  }

  [TestFixture]
  public class when_comparing
  {
      [Test]
      public void then_equal_operator_should_be_true_if_start_and_end_dates_are_the_same()
      {
          // Arrange
          var range1 = new DateRange(DateTime.Parse("1/1/2015"), DateTime.Parse("12/31/2015"));
          var range2 = new DateRange(DateTime.Parse("1/1/2015"), DateTime.Parse("12/31/2015"));

          // Act 
          var result = range1 == range2;

          // Assert
          Assert.That(result, Is.True);
      }
      [Test]
      public void then_not_equal_operator_should_be_true_if_start_and_end_dates_are_not_the_same()
      {
          // Arrange
          var range1 = new DateRange(DateTime.Parse("1/2/2015"), DateTime.Parse("12/31/2015"));
          var range2 = new DateRange(DateTime.Parse("1/1/2015"), DateTime.Parse("12/31/2015"));

          // Act 
          var result = range1 != range2;

          // Assert
          Assert.That(result, Is.True);
      }
  }

  [TestFixture]
  public class when_checking_in_range
  {
      [Test]
      public void then_should_return_true_given_date_between_start_and_end()
      {
          // Arrange
          var range = DateRange.FromDays(DateTime.Parse("2015-07-23"), 14);

          // Act
          var result = range.InRange(DateTime.Parse("2015-07-30"));

          // Assert
          Assert.That(result, Is.True);
      }
      [Test]
      public void then_should_return_false_given_date_not_between_before_start()
      {
          // Arrange
          var range = DateRange.FromDays(DateTime.Parse("2015-07-23"), 14);

          // Act
          var result = range.InRange(DateTime.Parse("2015-07-20"));

          // Assert
          Assert.That(result, Is.False);
      }
      [Test]
      public void then_should_return_false_given_date_not_after_end()
      {
          // Arrange
          var range = DateRange.FromDays(DateTime.Parse("2015-07-23"), 14);

          // Act
          var result = range.InRange(DateTime.Parse("2015-08-07"));

          // Assert
          Assert.That(result, Is.False);
      }
  }
}