public void When_subject_throws_the_expected_exact_exception_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act / Assert
//-----------------------------------------------------------------------------------------------------------
asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentNullException>())
.ShouldThrowExactly <ArgumentNullException>();
}
public void When_asserting_async_void_method_should_not_throw_specific_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
Action asyncVoidMethod = async() => await asyncObject.IncompleteTask();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncVoidMethod.Should().NotThrow <ArgumentException>();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.Should().Throw <InvalidOperationException>("*async*void*");
}
public void When_async_method_does_not_throw_exception_and_that_was_expected_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.SucceedAsync())
.ShouldNotThrow();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_async_method_succeeds_and_expected_not_to_throw_particular_exception_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await asyncObject.SucceedAsync())
.ShouldNotThrow <InvalidOperationException>();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_async_method_throws_expected_exception_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentException>())
.ShouldThrow <ArgumentException>();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_async_method_throws_exception_and_expected_not_to_throw_another_one_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentException>())
.Should().NotThrow <InvalidOperationException>();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.Should().NotThrow();
}
public void When_async_method_throws_exception_and_no_exception_was_expected_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentException>())
.Should().NotThrow();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.Should().Throw <XunitException>()
.WithMessage("Did not expect any exception, but found a System.ArgumentException*");
}
public void When_async_method_throws_unexpected_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentException>())
.ShouldThrow <InvalidOperationException>("because {0} should do that", "IFoo.Do");
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Expected System.InvalidOperationException because IFoo.Do should do that, but found*System.ArgumentException*");
}
public void When_async_method_does_not_throw_expected_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.SucceedAsync())
.ShouldThrow <InvalidOperationException>("because {0} should do that", "IFoo.Do");
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Expected System.InvalidOperationException because IFoo.Do should do that, but no exception was thrown*");
}
public void When_async_method_throws_exception_expected_not_to_be_thrown_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentException>())
.ShouldNotThrow <ArgumentException>();
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Did not expect System.ArgumentException, but found one*");
}
public void When_subject_throws_subclass_of_expected_exact_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () => asyncObject
.Awaiting(async x => await x.ThrowAsync <ArgumentNullException>())
.ShouldThrowExactly <ArgumentException>("because {0} should do that", "IFoo.Do");
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Expected type to be System.ArgumentException because IFoo.Do should do that, but found System.ArgumentNullException.");
}
public void When_async_method_throws_expected_exception_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.ThrowAsync <ArgumentException>(); };
asyncFunction.ShouldThrow <ArgumentException>();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_async_method_does_not_throw_exception_and_expecting_not_to_throw_anything_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.SucceedAsync(); };
asyncFunction.ShouldNotThrow();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_async_method_does_not_throw_expected_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.SucceedAsync(); };
asyncFunction.ShouldThrow <InvalidOperationException>();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Expected System.InvalidOperationException, but no exception was thrown*");
}
public void When_async_method_throws_unexpected_exception_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.ThrowAsync <ArgumentException>(); };
asyncFunction.ShouldThrow <InvalidOperationException>();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Expected System.InvalidOperationException, but found*System.ArgumentException*");
}
public void When_async_method_throws_exception_and_expecting_not_to_throw_anything_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.ThrowAsync <ArgumentException>(); };
asyncFunction.ShouldNotThrow();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Did not expect any exception, but found a System.ArgumentException*");
}
public void When_async_method_throws_exception_expected_not_to_be_thrown_it_should_fail()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var asyncObject = new AsyncClass();
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action action = () =>
{
Func <Task> asyncFunction = async() => { await asyncObject.ThrowAsync <ArgumentException>(); };
asyncFunction.ShouldNotThrow <ArgumentException>();
};
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
action.ShouldThrow <AssertFailedException>()
.WithMessage("Did not expect System.ArgumentException, but found one",
ComparisonMode.StartWith);
}
