public void Should_fail_when_asserting_nullable_TimeSpan_value_with_a_value_to_be_null()
{
TimeSpan? nullableTimeSpan = new TimeSpan();
Action act = () => nullableTimeSpan.Should().NotHaveValue();
act.ShouldThrow<AssertFailedException>();
}
public void Should_support_chaining_constraints_with_and()
{
TimeSpan? nullableTimeSpan = new TimeSpan();
nullableTimeSpan.Should()
.HaveValue()
.And
.Be(new TimeSpan());
}
public void Should_succeed_when_asserting_nullable_TimeSpan_value_with_a_value_to_have_a_value()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
TimeSpan? nullableTimeSpan = new TimeSpan();
//-------------------------------------------------------------------------------------------------------------------
// Act / Assert
//-------------------------------------------------------------------------------------------------------------------
nullableTimeSpan.Should().HaveValue();
}
public void should_be_able_to_deseralize_timespan_objects_from_floatseconds()
{
var timespan = new TimeSpan(days: 1, hours: 2, minutes: 3, seconds: 4, milliseconds: 5);
var input = new Datum()
{
type = Datum.DatumType.R_NUM,
r_num = timespan.TotalSeconds
};
var output = DatumConvert.DeserializeObject<TimeSpan>(input, new TimeSpanConverter());
timespan.Should().Be(output);
}
public void When_time_is_within_specified_number_of_milliseconds_from_another_value_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var time = new TimeSpan(1, 12, 15, 31, 035);
var nearbyTime = new TimeSpan(1, 12, 15, 31, 000);
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => time.Should().BeCloseTo(nearbyTime, 35);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_time_is_greater_then_and_not_close_to_another_value_it_should_throw_with_descriptive_message()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var time = new TimeSpan(1, 12, 15, 31, 021);
var nearbyTime = new TimeSpan(1, 12, 15, 31, 000);
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => time.Should().BeCloseTo(nearbyTime, 20, "we want to test the error message");
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>()
.WithMessage(
"Expected time to be within 20 ms from 1d, 12h, 15m and 31s because we want to test the error message, but found 1d, 12h, 15m and 31.021s.");
}
public void When_time_is_greater_then_but_close_to_another_value_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var time = new TimeSpan(1, 12, 15, 31, 020);
var nearbyTime = new TimeSpan(1, 12, 15, 31, 000);
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => time.Should().BeCloseTo(nearbyTime);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void Should_succeed_when_asserting_nullable_TimeSpan_value_with_a_value_to_have_a_value()
{
TimeSpan? nullableTimeSpan = new TimeSpan();
nullableTimeSpan.Should().HaveValue();
}
public async Task Pipeline_can_be_used_to_time_an_operation()
{
var time = new TimeSpan();
var aggregator = Aggregator
.Create<BalanceProjection, IDomainEvent>((projection, events) =>
{
return Task.Run(() => Thread.Sleep(1000));
})
.Pipeline(async (projection, batch, next) =>
{
var stopwatch = new Stopwatch();
stopwatch.Start();
await next(projection, batch);
time = stopwatch.Elapsed;
});
await aggregator.Aggregate(null, null);
time.Should().BeGreaterOrEqualTo(TimeSpan.FromSeconds(1));
}
public void Should_support_chaining_constraints_with_and()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
TimeSpan? nullableTimeSpan = new TimeSpan();
//-------------------------------------------------------------------------------------------------------------------
// Act / Assert
//-------------------------------------------------------------------------------------------------------------------
nullableTimeSpan.Should()
.HaveValue()
.And
.Be(new TimeSpan());
}
public void When_asserting_a_nullable_TimeSpan_is_equal_to_the_same_nullable_TimeSpan_it_should_succed()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
TimeSpan? nullableTimeSpanA = new TimeSpan();
TimeSpan? nullableTimeSpanB = new TimeSpan();
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action action = () => nullableTimeSpanA.Should().Be(nullableTimeSpanB);
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
