The CallMethod of the PrivateAccessor is using reflection to invoke the required method. When an exception is thrown inside that method it will be wrapped by the reflection in a TargetInvocationException which is received in the test method.
Instead of the TargetInvocationException, throw the original exception.
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.
Docker is a container acting like an isolated environment. Research how the JustMock profiler can be registered into such container. Hosted VSTS should work on the same principle. Research how the registry could be accessed through VSTS extension or other tools.
Such example is the future mocking of the class Timer with a private callback.
The main point behind this request is to add new command line option to JustMockRunner in order to enable profiler without need for being registered, more details about this feature can be found on MSDN at https://msdn.microsoft.com/en-us/library/ee471451(v=vs.100).aspx
If I define a fluent API, I might have an interface such as this:
public interface IRegistrar {
IRegistrar UsingThis(object someThing);
IRegistrar UsingThat<TThatThing>() }
If I create a mock of this using the default Behaviour.RecursiveLoose and make no arrangements, calls to the methods will return new mocks of the type, rather than the same instance that was called.
It would be nice to have a behaviour type that can return the same instance (in this case the mocked instance) without having to define a stub for each method call.
My code under test might look like:
IRegistrar reg;
reg
.UsingThis(new object())
.UsingThat<int>();
Currently, a test on the second call will fail if written against the mock assigned to 'reg'.
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.
It would be good if we could use named parameters inside Mock.Arrange method.
I want to be able to arrange the return value of `new` expressions, like Mock.Arrange(() => new FileInfo()).Returns(mockFileInfo). Then, I expect that `new FileInfo()` will always return my mock instance.