public void VoidMethodWithThrows(
IFoo foo,
Action action,
Exception exception)
{
"Given a fake"
.x(() => foo = A.Fake<IFoo>());
"And an action"
.x(() => action = A.Fake<Action>());
"When a void method is configured to invoke a delegate twice then throw an exception"
.x(() =>
A.CallTo(() => foo.Bar()).Invokes(action).DoesNothing().Twice()
.Then.Throws<InvalidOperationException>());
"And the method is called 3 times"
.x(() =>
{
foo.Bar();
foo.Bar();
exception = Record.Exception(() => foo.Bar());
});
"Then the delegate is invoked twice"
.x(() => A.CallTo(() => action()).MustHaveHappened(Repeated.Exactly.Twice));
"And the third call throws an exception"
.x(() => exception.Should().BeAnExceptionOfType<InvalidOperationException>());
}
public void ExceptionInStage(TrackedCommand command, Exception exception)
{
"Given I have a command"
.Given(() =>
{
command = new TrackedCommand { A = 1, B = 2 };
});
"And a pipeline stage which causes an exception"
.And(() =>
{
var stageA = new ExceptionPipelineStage {Next = pipeline.IssueCommand};
pipeline.SetRoot(stageA);
});
"When the command is processed in the pipeline"
.When(async () =>
{
try
{
await pipeline.Execute(command);
}
catch (Exception ex)
{
exception = ex;
}
});
"Then the exception is not captured"
.Then(() =>
{
exception.Should().NotBeNull();
});
}
public static void TryingToGetAnIncorrectlyTypedConfigurationItem(Exception ex)
{
"Given a config file with a string named 'foo'"
.f(() =>
{
using (var writer = new StreamWriter("foo1.csx"))
{
writer.WriteLine(@"Configurator.Add(""foo"", ""abc"");");
writer.Flush();
}
})
.Teardown(() => File.Delete("foo1.csx"));
"When I load the file"
.When(() => Configurator.Load("foo1.csx"));
"And I try to get an integer named 'foo'"
.f(() => ex = Record.Exception(() => Configurator.Get<int>("foo")))
.Teardown(() => Configurator.Unload());
"Then an exception is thrown"
.f(() => ex.Should().NotBeNull());
"And the exception message contains 'foo'"
.f(() => ex.Message.Should().Contain("foo"));
"And the exception contains an inner exception"
.f(() => ex.InnerException.Should().NotBeNull());
"And the inner exception message contains 'string'"
.f(() => ex.InnerException.Message.Should().Contain("string"));
"And the inner exception message contains 'int'"
.f(() => ex.InnerException.Message.Should().Contain("int"));
}
public static void DependencyFails(ITaskBuilder builder, bool defaultExecuted, Exception ex)
{
"And a non-default task which fails"
.f(c => builder = ScriptCs.Require<Bau>()
.Task("non-default").DependsOn("default")
.Do(() =>
{
throw new Exception();
}));
"And a default task which depends on the non-default task"
.f(c => builder
.Task("default").DependsOn("non-default")
.Do(() => defaultExecuted = true));
"When I run the builder"
.f(() => ex = Record.Exception(() => builder.Run()));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And the default task is not executed"
.f(() => defaultExecuted.Should().BeFalse());
"And I am informed that the non-default task was executed"
.f(() => ex.Message.Should().Contain("'non-default' task failed."));
}
public static void TryingToGetAnIncorrectlyTypedConfigurationItem(Exception ex)
{
"Given a config file with a string named 'foo'"
.f(() =>
{
// TODO (Adam): add DSL - new TempFile(string path, string content).Using();
using (var writer = new StreamWriter("foo1.csx"))
{
writer.WriteLine(@"Add(""foo"", ""abc"");");
writer.Flush();
}
})
.Teardown(() => File.Delete("foo1.csx"));
"When I load the file"
.f(() => Config.Global.LoadScriptFile("foo1.csx"));
"And I try to get an integer named 'foo'"
.f(() => ex = Record.Exception(() => Config.Global.Get<int>("foo")));
"Then an exception is thrown"
.f(() => ex.Should().NotBeNull());
"And the exception message contains 'foo'"
.f(() => ex.Message.Should().Contain("foo"));
"And the exception message contains the full type name of int"
.f(() => ex.Message.Should().Contain(typeof(int).FullName));
"And the exception message contains the full type name of string"
.f(() => ex.Message.Should().Contain(typeof(string).FullName));
}
public static void RepeatedAssertion(
IMyInterface fake,
Exception exception)
{
"establish"
.x(() =>
{
fake = A.Fake<IMyInterface>(o => o.Strict());
////fake = A.Fake<IMyInterface>();
A.CallTo(() => fake.DoIt(Guid.Empty)).Invokes(() => { });
fake.DoIt(Guid.Empty);
fake.DoIt(Guid.Empty);
});
"when asserting must have happened when did not happen"
.x(() => exception = Record.Exception(() => A.CallTo(() => fake.DoIt(Guid.Empty)).MustHaveHappened(Repeated.Exactly.Once)));
"it should throw an expectation exception"
.x(() => exception.Should().BeAnExceptionOfType<ExpectationException>());
"it should have an exception message containing the name of the method"
.x(() => exception.Message.Should().Contain("DoIt"));
}
public void Should_support_chaining_constraints_with_and()
{
var someObject = new Exception();
someObject.Should()
.BeOfType<Exception>()
.And
.NotBeNull();
}
public static void ConfiguringSetterWithNull(
Exception exception)
{
"When assignment of a property is configured using a null expression"
.x(() => exception = Record.Exception(() => A.CallToSet<int>(null)));
"Then an argument null exception is thrown"
.x(() => exception.Should().BeAnExceptionOfType<ArgumentNullException>());
"And the parameter name is 'propertySpecification'"
.x(() => exception.As<ArgumentNullException>().ParamName.Should().Be("propertySpecification"));
}
public static void ConfiguringNonConfigurableSetter(
ClassWithInterestingProperties subject,
Exception exception)
{
"Given a Fake with a property that can't be configured"
.x(() => subject = A.Fake<ClassWithInterestingProperties>());
"When assignment of the property is configured"
.x(() => exception = Record.Exception(() => A.CallToSet(() => subject.NonConfigurableProperty).DoesNothing()));
"Then a fake configuration exception is thrown"
.x(() => exception.Should().BeAnExceptionOfType<FakeConfigurationException>());
}
public static void NoTasksExist(ITaskBuilder builder, Exception ex)
{
"Given no tasks"
.f(() => builder = ScriptCs.Require<Bau>());
"When I run the builder"
.f(() => ex = Record.Exception(() => builder.Run()));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And I am informed that the default task was not found"
.f(() => ex.Message.Should().Contain("'default' task not found"));
}
public void OverrideInternalMethod(
TypeWithInternalMethod fake,
Exception exception)
{
"establish"
.x(() => fake = A.Fake<TypeWithInternalMethod>());
"when trying to override internal method on type"
.x(() => exception = Record.Exception(() => A.CallTo(() => fake.InternalMethod()).Returns(17)));
"it should throw an exception with a message complaining about accessibility"
.x(() => exception.Should().BeAnExceptionOfType<FakeConfigurationException>()
.And.Message.Should().Contain("not accessible to DynamicProxyGenAssembly2"));
}
public static void NonexistentTask(string tag, string code, Baufile baufile, Exception ex)
{
var scenario = MethodBase.GetCurrentMethod().GetFullName();
"Given a baufile containing {0}"
.f(() => baufile = Baufile.Create(string.Concat(scenario, ".", tag)).WriteLine(code));
"When I execute a non-existent task"
.f(() => ex = Record.Exception(() => baufile.Run("non-existent")));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And I am informed that the non-existent task was not found"
.f(() => ex.Message.Should().ContainEquivalentOf("'non-existent' task not found"));
}
public static void CompilationFails(Baufile baufile, Exception ex)
{
var scenario = MethodBase.GetCurrentMethod().GetFullName();
"Given a baufile containing an unknown name"
.f(() => baufile = Baufile.Create(scenario).WriteLine(@"x"));
"When I execute the baufile"
.f(() => ex = Record.Exception(() => baufile.Run()));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And I am informed that member could not be found"
.f(() => ex.Message.Should().ContainEquivalentOf("the name 'x' does not exist in the current context"));
}
public static void CallsToVoidMethodThrows(
Fake<IFoo> fake,
Exception exception)
{
"Given an unnatural fake"
.x(() => fake = new Fake<IFoo>());
"And I configure a void method to throw an exception"
.x(() => fake.CallsTo(f => f.VoidMethod()).Throws<ArithmeticException>());
"When I call the method on the faked object"
.x(() => exception = Record.Exception(() => fake.FakedObject.VoidMethod()));
"Then it throws the exception"
.x(() => exception.Should().BeAnExceptionOfType<ArithmeticException>());
}
public static void CallsToVoidMethodDoesNothing(
Fake<AClass> fake,
Exception exception)
{
"Given a strict unnatural fake"
.x(() => fake = new Fake<AClass>(options => options.Strict()));
"And I configure a void method to do nothing"
.x(() => fake.CallsTo(f => f.VoidMethod()).DoesNothing());
"When I call the method on the faked object"
.x(() => exception = Record.Exception(() => fake.FakedObject.VoidMethod()));
"Then it doesn't throw"
.x(() => exception.Should().BeNull());
}
public static void ExecutionFails(Baufile baufile, Exception ex, string message)
{
var scenario = MethodBase.GetCurrentMethod().GetFullName();
"Given a baufile which throws an exception"
.f(() => baufile = Baufile.Create(scenario).WriteLine(
@"throw new Exception(""" + (message = Guid.NewGuid().ToString()) + @""");"));
"When I execute the baufile"
.f(() => ex = Record.Exception(() => baufile.Run()));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And I see details of the exception"
.f(() => ex.Message.Should().Contain(message));
}
public static void NoTasksExist(ITaskBuilder builder, Exception ex)
{
"Given a non-existent task is specified"
.f(() => builder = ScriptCs.Require<Bau>(new[] { "non-existent" }));
"And no tasks"
.f(() => { });
"When I run the builder"
.f(() => ex = Record.Exception(() => builder.Run()));
"Then execution should fail"
.f(() => ex.Should().NotBeNull());
"And I am informed that the non-existent task was not found"
.f(() => ex.Message.Should().Contain("'non-existent' task not found"));
}
public void CanceledToken(
IFoo fake,
CancellationToken cancellationToken,
Exception exception)
{
"Given a fake"
.x(() => fake = A.Fake<IFoo>());
"And a cancellation token that is canceled"
.x(() => cancellationToken = new CancellationToken(true));
"When a method is called with this cancellation token"
.x(() => exception = Record.Exception(() => fake.Bar(cancellationToken)));
"Then it throws an OperationCanceledException"
.x(() => exception.Should().BeAnExceptionAssignableTo<OperationCanceledException>());
}
public static void ConfiguringSetterForReadOnlyProperty(
IHaveInterestingProperties subject,
Exception exception)
{
"Given a Fake with a read-only property"
.x(() => subject = A.Fake<IHaveInterestingProperties>());
"When assignment of the property is configured"
.x(() => exception = Record.Exception(() => A.CallToSet(() => subject.ReadOnlyProperty).DoesNothing()));
"Then an argument exception is thrown"
.x(() => exception.Should().BeAnExceptionOfType<ArgumentException>());
"And the exception message indicates that the property is read-only"
.x(() => exception.Message.Should().Be(
$"The property '{nameof(IHaveInterestingProperties.ReadOnlyProperty)}' does not have a setter."));
}
public void ThrowingConstructor(
Exception exception)
{
"when faking a class whose constructor throws"
.x(() => exception = Record.Exception(() => A.Fake<ClassWhoseConstructorThrows>()));
"it should throw a fake creation exception"
.x(() => exception.Should().BeOfType<FakeCreationException>());
"it should throw an exception whose message includes original exception type"
.x(() => exception.Message.Should().Contain("of type System.NotSupportedException"));
"it should throw an exception whose message includes original exception message"
.x(() => exception.Message.Should().Contain("I don't like being constructed."));
"it should throw an exception whose message includes original exception stack trace"
.x(() => exception.Message.Should().Contain("FakeItEasy.Specs.ClassWhoseConstructorThrows..ctor()"));
}
public static void ConfigValueHasActionProperty(Exception exception)
{
"Given a local config file containing a value with an action property"
.f(() =>
{
using (var writer = new StreamWriter(LocalScriptFileConfig.Path))
{
writer.WriteLine(@"#r ""ConfigR.Features.dll""");
writer.WriteLine(@"using ConfigR.Features;");
writer.WriteLine(@"Add(""foo"", new Foo { Action = () => Console.WriteLine(""hello world"") });");
writer.Flush();
}
})
.Teardown(() => File.Delete(LocalScriptFileConfig.Path));
"When I get the value"
.f(() => exception = Record.Exception(() => Config.Global.Get<Foo>("foo")));
"Then no exception is thrown"
.f(() => exception.Should().BeNull());
}
public static void Throws(
Func<string, int> fakedDelegate,
FormatException expectedException,
Exception exception)
{
"establish"
.x(() => fakedDelegate = A.Fake<Func<string, int>>());
"establish"
.x(() =>
{
expectedException = new FormatException();
A.CallTo(() => fakedDelegate.Invoke(A<string>._)).Throws(expectedException);
});
"when faking a delegate type and invoking with throwing configuration"
.x(() => exception = Record.Exception(() => fakedDelegate(null)));
"it should throw the configured exception"
.x(() => exception.Should().BeSameAs(expectedException));
}
public void InitializeALoadedStateMachine(
PassiveStateMachine<int, int> machine,
Exception receivedException)
{
"establish a loaded state machine"._(() =>
{
machine = new PassiveStateMachine<int, int>();
machine.Load(A.Fake<IStateMachineLoader<int>>());
});
"when initializing the state machine"._(() =>
receivedException = Catch.Exception(() =>
machine.Initialize(0)));
"should throw an invalid operation exception"._(() =>
{
receivedException
.Should().BeAssignableTo<InvalidOperationException>();
receivedException.Message
.Should().Be(ExceptionMessages.StateMachineIsAlreadyInitialized);
});
}
public void When_object_type_is_exactly_equal_to_the_specified_type_it_should_not_fail()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var someObject = new Exception();
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () => someObject.Should().BeOfType<Exception>();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_object_is_of_the_expected_type_it_should_cast_the_returned_object_for_chaining()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var someObject = new Exception("Actual Message");
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () => someObject.Should().BeOfType<Exception>().Which.Message.Should().Be("Other Message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>().WithMessage("*Expected*Other*Actual*");
}
public static void WithAdditionalAttributesAndNullSetOfAttributes(
Exception exception)
{
"When a fake is built with a null set of additional attributes"
.x(() => exception = Record.Exception(() => A.Fake<IInterfaceThatWeWillAddAttributesTo2>(options => options.WithAdditionalAttributes(null))));
"Then it should throw an argument null exception"
.x(() => exception.Should().BeAnExceptionOfType<ArgumentNullException>()
.WithMessage("*customAttributeBuilders*"));
}
public static void MultipleReturns(
IFoo fake,
IReturnValueArgumentValidationConfiguration<int> configuration,
Exception exception)
{
"establish"
.x(() => fake = A.Fake<IFoo>());
"when configuring multiple returns on the same configuration"
.x(() =>
{
configuration = A.CallTo(() => fake.Baz());
configuration.Returns(42);
exception = Record.Exception(() => configuration.Returns(0));
});
"it should throw an invalid operation exception"
.x(() => exception.Should().BeAnExceptionOfType<InvalidOperationException>());
}
public static void MultipleReturns(
IFoo fake,
IReturnValueArgumentValidationConfiguration<int> configuration,
Exception exception)
{
"Given a fake"
.x(() => fake = A.Fake<IFoo>());
"And I configure the return value for the method"
.x(() =>
{
configuration = A.CallTo(() => fake.Baz());
configuration.Returns(42);
});
"When I use the same configuration object to set the return value again"
.x(() => exception = Record.Exception(() => configuration.Returns(0)));
"Then it throws an invalid operation exception"
.x(() => exception.Should().BeAnExceptionOfType<InvalidOperationException>());
}
public static void UnusedNonVoidCallSpec(
IFoo fake,
Exception exception)
{
"Given a strict fake"
.x(() => fake = A.Fake<IFoo>(o => o.Strict()));
"When I specify a call to a void method without configuring its behavior"
.x(() => A.CallTo(() => fake.Baz()));
"And I make a call to that method"
.x(() => exception = Record.Exception(() => fake.Baz()));
"Then it throws an expectation exception"
.x(() => exception.Should().BeAnExceptionOfType<ExpectationException>());
}
public static void InvokesAfterStrictVoid(
IFoo fake,
Exception exception)
{
"Given a strict fake"
.x(() => fake = A.Fake<IFoo>(options => options.Strict()));
"And I configure a void method to invoke an action"
.x(() => A.CallTo(() => fake.Bar()).Invokes(() => { }));
"When I call the method"
.x(() => exception = Record.Exception(() => fake.Bar()));
"Then it does not throw an exception"
.x(() => exception.Should().BeNull());
}
