Allow the developer to create custom behaviors and use them in an arrangement. Something like the following:
Mock.Arrange(() => foo.CalcData(Arg.AnyInt, Arg.AnyInt), new IBehavior[]
{
new LogInvocation(),
new ReturnBaseOrDefaultValue(),
});
The new public API should allow the developer to access the invocations for a particular arrangement. Something like the following:
IEnumerable<IInvocaiton> invocations = foo.GetInvocationsFor((x) => x.CalcData(2, 2));
Implement a new public API that will allow the developer to iterate over all invocations of mock arrangements. Something like the following:
IEnumerable<IInvocaiton> invocations = Mock.Invocations;
Implement support for mocking of an operator such as the one described.
Hi I have encountered what I think is a bug.
I would expected the following unit test to pass. It does not.
The example is distilled from a more complex case.
Is it not supported to have other threads create mocks?
[Fact]
public async Task Fails()
{
var iTask = Task.Run(() => Mock.Create<I>());
var i = await iTask;
EA expectedArgs = new EA();
EA receivedArgs = null;
i.Done += (sender, ea) => receivedArgs = ea;
i.Raise(x => x.Done += null, expectedArgs);
Assert.Equal(expectedArgs, receivedArgs);
}
public class EA : EventArgs
{
}
public interface I
{
event EventHandler<EA> Done;
}
Let's have the following class and unit test:
public delegate Task<int> SomeDelegate();
{
public async Task<int> ExecuteAsync(SomeDelegate next)
{
Task<int> task1 = next.Invoke();
int int1 = await DoSomeStuff();
int int2 = await task1;
}
private async Task<int> DoSomeStuff()
{
await Task.Delay(100);
return 1;
}
}
public async Task TestMethod1()
{
// Arrange
SomeDelegate next = Mock.Create<SomeDelegate>();
next.Arrange(n => n.Invoke()).TaskResult(2).OccursOnce();
int sum = await new Class1().ExecuteAsync(next);
// Assert
Mock.Assert(next);
Assert.AreEqual(3, sum);
}
JustMock public API lacks of convenient way to assert that particular task has been awaited. Potential workaround involves some "insider knowledge" that awaiting a Task internally results in a calls to some of its members.
Allow future mocking of an entire class, including a default of DoNothing() for all methods in the class, rather than requiring each method to be future mocked separately.
Currently, there is no out of the box support for passing "out" and "ref" parameters for nonpublic API.