public async Task PublishSuccessful()
{
// Arrange
var @event = EventFake.GetEventFake();
_busService.When(b => b.PublishAsync(Arg.Any <EventMessage>(), Arg.Any <CancellationToken>())).Do(
Callback.Always(async x =>
{
await _systemUnderTest.EventMessageReceived(new EventMessage
{
Event = @event.ToBytes()
}, CancellationToken.None);
}));
// Act
_systemUnderTest.RegisterEventHandler(_eventHandler);
await _systemUnderTest.PublishAsync(@event, CancellationToken.None);
// Assert
await _busService.Received().PublishAsync(Arg.Any <EventMessage>(), Arg.Any <CancellationToken>());
await _eventHandler.Received()
.ExecuteInternalAsync(
Arg.Is <EventFake>(x =>
x.Model.Id == ((EventFake)@event).Model.Id && x.Model.Name == ((EventFake)@event).Model.Name),
Arg.Any <CancellationToken>());
}
public void Execute_when_called_for_any_args()
{
var called = false;
_something.WhenForAnyArgs(x => x.Echo(1)).Do(Callback.Always(x => called = true));
Assert.That(called, Is.False, "Called");
_something.Echo(1234);
Assert.That(called, Is.True, "Called");
}
public void Capture_arguments_when_called()
{
int firstArgument = 0;
_something.When(substitute => substitute.Echo(1)).Do(Callback.Always(info => firstArgument = (int)info[0]));
Assert.That(firstArgument, Is.EqualTo(0), "firstArgument");
_something.Echo(1);
Assert.That(firstArgument, Is.EqualTo(1), "firstArgument");
}
public void Execute_when_called()
{
var called = false;
_something.When(substitute => substitute.Echo(1)).Do(Callback.Always(info => called = true));
Assert.That(called, Is.False, "Called");
_something.Echo(1);
Assert.That(called, Is.True, "Called");
}
public void Only_do_matching_actions()
{
int called = 0;
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.Always(x => called++));
_something.When(x => x.Echo(4)).Do(Callback.Always(x => called++));
Assert.That(called, Is.EqualTo(0), "Should not have been called yet");
_something.Echo(1);
Assert.That(called, Is.EqualTo(1));
}
public void Run_multiple_actions_when_called()
{
int called = 0;
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.Always(x => called++));
_something.When(x => x.Echo(4)).Do(Callback.Always(x => called++));
_something.WhenForAnyArgs(x => x.Echo(1234)).Do(Callback.Always(x => called++));
Assert.That(called, Is.EqualTo(0), "Should not have been called yet");
_something.Echo(4);
Assert.That(called, Is.EqualTo(3));
}
public void Throw_exception_when_Throw_with_specific_exception()
{
var exception = new IndexOutOfRangeException("Test");
int called = 0;
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.Always(x => called++));
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.FirstThrow(exception));
Assert.That(called, Is.EqualTo(0), "Should not have been called yet");
var thrownException = Assert.Throws <IndexOutOfRangeException>(() => _something.Echo(1234));
Assert.That(thrownException, Is.EqualTo(exception));
Assert.That(called, Is.EqualTo(1));
}
public void AlwaysIsCalledAlways()
{
var calls = new List <int>();
int callCount = 0;
_something.When(x => x.Count()).Do(Callback.Always(x => calls.Add(++callCount)));
Assert.That(callCount, Is.EqualTo(0), "Should not have been called yet");
_something.Count();
_something.Count();
Assert.AreEqual(new List <int> {
1, 2
}, calls);
}
public void Throw_exception_when_Throw_with_exception_generator()
{
Func <CallInfo, Exception> createException = ci => new ArgumentException("Argument: " + ci.Args()[0]);
int called = 0;
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.Always(x => called++));
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.AlwaysThrow(createException));
Assert.That(called, Is.EqualTo(0), "Should not have been called yet");
var thrownException = Assert.Throws <ArgumentException>(() => _something.Echo(1234));
Assert.That(thrownException.Message, Is.EqualTo("Argument: 1234"));
Assert.That(called, Is.EqualTo(1));
}
public void Throw_exception_when_Throw_with_generic_exception()
{
int called = 0;
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.Always(x => called++));
var expectedException = new ArgumentException();
_something.When(x => x.Echo(Arg.Any <int>())).Do(Callback.FirstThrow(expectedException));
Assert.That(called, Is.EqualTo(0), "Should not have been called yet");
var actualException = Assert.Throws <ArgumentException>(() => _something.Echo(1234));
Assert.That(actualException, Is.EqualTo(expectedException));
Assert.That(called, Is.EqualTo(1));
}
