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); }