public async Task AsyncProxy_OnBeforeInvoke_ArgumentsSetCorrectly()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndAsyncProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.AreEqual(false, args.IsRetry, "IsRetry is not set correctly");
Assert.AreEqual(0, args.RetryCounter, "RetryCounter is not set correctly");
Assert.AreEqual(typeof(ITestService), args.ServiceType, "ServiceType is not set correctly");
resetEvent.Set();
};
c.OnBeforeInvoke += handler;
});
await proxy.CallAsync(m => m.VoidMethod("test"));
resetEvent.WaitOrFail("OnBeforeInvoke hasn't been called");;
}
public void Proxy_OnAfterInvoke_ReturnValue_ForValueTypeMethods_IsSetCorrectly()
{
var service = Substitute.For<ITestService>();
service
.IntMethod()
.Returns(1337);
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.IsTrue(args.InvokeInfo.MethodHasReturnValue, "InvokeInfo.MethodHasReturnValue is not set correctly");
Assert.AreEqual(1337, args.InvokeInfo.ReturnValue, "InvokeInfo.ReturnValue is not set correctly");
resetEvent.Set();
};
c.OnAfterInvoke += handler;
});
proxy.IntMethod();
resetEvent.WaitOrFail("OnAfterInvoke not fired");
}
public void Proxy_OnAfterInvoke_ReturnValue_ThrowsForVoidMethods()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.IsFalse(args.InvokeInfo.MethodHasReturnValue, "InvokeInfo.MethodHasReturnValue is not set correctly");
Assert.Throws<InvalidOperationException>(delegate { var x = args.InvokeInfo.ReturnValue; }, "InvokeInfo.ReturnValue did not throw!");
resetEvent.Set();
};
c.OnAfterInvoke += handler;
});
proxy.VoidMethod("test");
resetEvent.WaitOrFail("OnAfterInvoke not fired");
}
public void Proxy_OnAfterInvoke_ArgumentsSetCorrectly()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (object sender, OnInvokeHandlerArguments args) =>
{
Assert.AreEqual(false, args.IsRetry, "IsRetry is not set correctly");
Assert.AreEqual(0, args.RetryCounter, "RetryCounter is not set correctly");
Assert.AreEqual(typeof(ITestService), args.ServiceType, "ServiceType is not set correctly");
resetEvent.Set();
};
c.OnAfterInvoke += handler;
});
proxy.VoidMethod("test");
resetEvent.WaitOrFail("OnBeforeInvoke not fired");
}
public void Proxy_OnAfterInvoke_InvokeInfo_SetCorrectly()
{
var service = Substitute.For<ITestService>();
Request request = new Request { RequestMessage = "message" };
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.AreEqual("TestMethodComplexMulti", args.InvokeInfo.MethodName, "InvokeInfo.MethodName is not set correctly");
// parameters
Assert.AreEqual(2, args.InvokeInfo.Parameters.Length, "InvokeInfo.Parameters length is incorrect");
Assert.AreEqual("test", args.InvokeInfo.Parameters[0], "InvokeInfo.Parameters[0] is not set correctly");
Assert.AreEqual(request, args.InvokeInfo.Parameters[1], "InvokeInfo.Parameters[1] is not set correctly");
resetEvent.Set();
};
c.OnAfterInvoke += handler;
});
proxy.TestMethodComplexMulti("test", request);
resetEvent.WaitOrFail("OnAfterInvoke not fired");
}
public void Proxy_OnBeforeInvoke_InvokeInfo_IsSet()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.IsNotNull(args.InvokeInfo, "InvokeInfo is null when it should be set");
resetEvent.Set();
};
c.OnBeforeInvoke += handler;
});
proxy.TestMethod("test");
resetEvent.WaitOrFail("OnBeforeInvoke not fired");
}
public void Proxy_OnBeforeInvoke_InvokeInfo_SetCorrectly_IntParameter()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.AreEqual("VoidMethodIntParameter", args.InvokeInfo.MethodName, "InvokeInfo.MethodName is not set correctly");
Assert.AreEqual(1, args.InvokeInfo.Parameters.Length, "InvokeInfo.Parameters length is incorrect");
Assert.AreEqual(1337, args.InvokeInfo.Parameters[0], "InvokeInfo.Parameters[0] is not set correctly");
resetEvent.Set();
};
c.OnBeforeInvoke += handler;
});
proxy.VoidMethodIntParameter(1337);
resetEvent.WaitOrFail("OnBeforeInvoke not fired");
}
public void AsyncProxy_OnException_IsFired()
{
var service = Substitute.For<ITestService>();
service
.When(m => m.VoidMethod("test"))
.Throw(new FaultException());
bool hasFired = false;
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndAsyncProxy(c =>
{
c.OnException += (sender, args) =>
{
hasFired = true;
resetEvent.Set();
};
});
Assert.ThrowsAsync<FaultException>(
() => proxy.CallAsync(m => m.VoidMethod("test")));
resetEvent.WaitOrFail("OnException not fired");
Assert.IsTrue(hasFired);
}
public async Task Async_HandleResponse_ActionWithoutPredicate_CanInspectResponse_WithoutReturning()
{
var resetEvent = new AutoResetEvent(false);
var service = Substitute.For<ITestService>();
const string expectedInput = "test";
service
.TestMethod(expectedInput)
.Returns(m => m.Arg<string>());
var proxy = service.StartHostAndAsyncProxy(c =>
{
c.HandleResponse<string>(handler: r =>
{
Assert.That(r, Is.EqualTo(expectedInput));
resetEvent.Set();
});
});
var response = await proxy.CallAsync(m => m.TestMethod(expectedInput));
Assert.That(response, Is.EqualTo(expectedInput));
resetEvent.WaitOrFail("Callback not fired");
}
public void Proxy_OnException_InformationSetCorrectly()
{
var service = Substitute.For<ITestService>();
service
.When(m => m.VoidMethod("test"))
.Throw(new FaultException());
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndProxy(c =>
{
c.OnException += (sender, args) =>
{
Assert.IsInstanceOf<FaultException>(args.Exception, "Exception");
Assert.AreEqual("VoidMethod", args.InvokeInfo.MethodName, "InvokeInfo.MethodName");
Assert.AreEqual(typeof(ITestService), args.ServiceType, "ServiceType");
resetEvent.Set();
};
});
Assert.Catch<FaultException>(() => proxy.VoidMethod("test"));
resetEvent.WaitOrFail("OnException not fired");
}
public async Task AsyncProxy_OnCallSuccess_IsFired()
{
var service = Substitute.For<ITestService>();
service
.TestMethod("test")
.Returns("OK")
.AndDoes(_ => Thread.Sleep(500));
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndAsyncProxy(c =>
{
c.OnCallSuccess += (invoker, args) =>
{
Assert.That(args.InvokeInfo.MethodName, Is.EqualTo("TestMethodAsync"));
Assert.That(args.InvokeInfo.ReturnValue, Is.EqualTo("OK"));
Assert.That(args.CallDuration, Is.GreaterThan(TimeSpan.MinValue));
resetEvent.Set();
};
});
await proxy.CallAsync(m => m.TestMethod("test"));
resetEvent.WaitOrFail("OnCallSuccess was not triggered");
}
public async Task AsyncProxy_OnCallBegin_IsFired()
{
var service = Substitute.For<ITestService>();
service
.TestMethod("test")
.Returns("OK");
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndAsyncProxy(c =>
{
c.OnCallBegin += (invoker, args) =>
{
Assert.That(args.InvokeInfo.MethodName, Is.EqualTo("TestMethodAsync"));
resetEvent.Set();
};
});
await proxy.CallAsync(m => m.TestMethod("test"));
resetEvent.WaitOrFail("OnCallBegin was not triggered");
}
public async Task AsyncProxy_OnAfterInvoke_InvokeInfo_IsSet()
{
var service = Substitute.For<ITestService>();
var resetEvent = new AutoResetEvent(false);
var proxy = service.StartHostAndAsyncProxy(c =>
{
OnInvokeHandler handler = (sender, args) =>
{
Assert.IsNotNull(args.InvokeInfo, "InvokeInfo is null when it should be set");
resetEvent.Set();
};
c.OnAfterInvoke += handler;
});
await proxy.CallAsync(m => m.TestMethod("test"));
resetEvent.WaitOrFail("OnAfterInvoke not called");
}
public async Task AsyncProxy_OnBeforeInvoke_IfRetry_FiredManyTimes()
{
var resetEvent = new AutoResetEvent(false);
// set up a service method that throws first two times, and completes on the third time
var service = Substitute.For<ITestService>();
int mockFireCount = 0;
service
.When(m => m.VoidMethod(Arg.Any<string>()))
.Do(_ =>
{
// fail on first two calls, return on subsequent calls
mockFireCount++;
if (mockFireCount < 3)
throw new Exception();
});
int fireCount = 0;
var proxy = service.StartHostAndAsyncProxy(c =>
{
c.MaximumRetries(10);
c.RetryOnException<FaultException>();
c.RetryOnException<FaultException<ExceptionDetail>>();
OnInvokeHandler handler = (sender, args) =>
{
fireCount++;
Assert.AreEqual(fireCount > 1, args.IsRetry, "IsRetry is not set correctly");
Assert.AreEqual(fireCount - 1, args.RetryCounter, "RetryCounter is not set correctly");
Assert.AreEqual(typeof(ITestService), args.ServiceType, "ServiceType is not set correctly");
if (fireCount >= 2)
resetEvent.Set();
};
c.OnBeforeInvoke += handler;
});
await proxy.CallAsync(m => m.VoidMethod("test"));
resetEvent.WaitOrFail("OnBeforeInvoke probably not called");
Assert.AreEqual(3, fireCount, "Not called three times!");
}
