public async Task ServiceContractDefinedAsyncMethod_WithNoReturnValue()
{
var resetEvent = new AutoResetEvent(false);
var mockService = new Mock <IAsyncTestInterface>();
mockService
.Setup(m => m.VoidMethodDefinedAsync("test"))
.Returns(Task.FromResult(true))
.Callback(() =>
{
Console.WriteLine("Callback thread: " + Thread.CurrentThread.ManagedThreadId);
resetEvent.Set();
});
var serviceHost = InProcTestFactory.CreateHost <IAsyncTestInterface>(new AsyncTestInterfaceImpl(mockService));
var proxy = WcfClientProxy.Create <IAsyncTestInterface>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
Console.WriteLine("Caller thread: " + Thread.CurrentThread.ManagedThreadId);
await proxy.VoidMethodDefinedAsync("test");
Console.WriteLine("Contination thread: " + Thread.CurrentThread.ManagedThreadId);
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(2)))
{
Assert.Fail("Callback never called");
}
}
public void DuplexService_WithInstanceContext_TriggersCallback()
{
var resetEvent = new AutoResetEvent(false);
var serviceHost = InProcTestFactory.CreateHost <IDuplexService>(new DuplexService());
var callback = Substitute.For <IDuplexServiceCallback>();
callback
.TestCallback(Arg.Any <string>())
.Returns(m => m.Arg <string>())
.AndDoes(_ => resetEvent.Set());
InstanceContext <IDuplexServiceCallback> ctx = new InstanceContext <IDuplexServiceCallback>(callback);
var proxy = WcfClientProxy.Create <IDuplexService>(c =>
{
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress, ctx);
});
proxy.Test("test");
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
{
Assert.Fail("Callback not entered");
}
}
public async Task CallAsync_MethodWithReturnValue()
{
var mockService = new Mock <ITestService>();
mockService
.SetupSequence(m => m.TestMethod("good"))
.Returns("BAD")
.Returns("OK");
mockService.Setup(m => m.TestMethod("second", "two")).Returns("2");
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService>(c =>
{
c.MaximumRetries(1);
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress);
c.RetryOnResponse <string>(s => s == "BAD");
});
Console.WriteLine("Caller thread: " + Thread.CurrentThread.ManagedThreadId);
string result = await proxy.CallAsync(m => m.TestMethod("good"));
string result2 = await proxy.CallAsync(m => m.TestMethod("second", "two"));
Console.WriteLine("Continuation thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.That(result, Is.EqualTo("OK"));
Assert.That(result2, Is.EqualTo("2"));
}
public void CallAsync_MultipleConcurrentCalls()
{
int iterations = 20;
var mockService = new Mock <ITestService2>();
mockService
.Setup(m => m.TestMethod(It.IsAny <string>()))
.Returns((string s) => "Echo: " + s)
.Callback((string s) => Console.WriteLine("Callback: " + s));
var serviceHost = InProcTestFactory.CreateHost <ITestService2>(new TestService2Impl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService2>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
var tasks = new List <Task>();
for (int i = 0; i < iterations; i++)
{
int i1 = i;
tasks.Add(proxy.CallAsync(m => m.TestMethod(i1.ToString())));
Console.WriteLine("Queued task: " + i);
}
Console.WriteLine("Waiting tasks...");
Task.WaitAll(tasks.ToArray());
for (int i = 0; i < iterations; i++)
{
string result = ((Task <string>)tasks[i]).Result;
Assert.That(result, Is.EqualTo("Echo: " + i));
}
}
public async Task CallAsync_OneWayOperation()
{
var resetEvent = new AutoResetEvent(false);
var mockService = new Mock <ITestService>();
mockService
.Setup(m => m.OneWay(It.IsAny <string>()))
.Callback((string input) =>
{
Assert.That(input, Is.EqualTo("test"));
Console.WriteLine("Callback thread: " + Thread.CurrentThread.ManagedThreadId);
resetEvent.Set();
});
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
await proxy.CallAsync(m => m.OneWay("test"));
Console.WriteLine("Continuation thread: " + Thread.CurrentThread.ManagedThreadId);
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
{
Assert.Fail("Callback not entered");
}
}
public async Task CallAsync_VoidMethod()
{
var resetEvent = new AutoResetEvent(false);
var mockService = new Mock <ITestService>();
mockService
.Setup(m => m.VoidMethod("good"))
.Callback(() =>
{
Console.WriteLine("Callback thread: " + Thread.CurrentThread.ManagedThreadId);
resetEvent.Set();
});
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
Console.WriteLine("Caller thread: " + Thread.CurrentThread.ManagedThreadId);
await proxy.CallAsync(m => m.VoidMethod("good"));
Console.WriteLine("Continuation thread: " + Thread.CurrentThread.ManagedThreadId);
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(2)))
{
Assert.Fail("Callback never triggered");
}
}
public void DuplexService_OneWayOperation_TriggersCallback()
{
var resetEvent = new AutoResetEvent(false);
var serviceHost = InProcTestFactory.CreateHost <IDuplexService>(new DuplexService());
var callback = new Mock <IDuplexServiceCallback>();
callback
.Setup(m => m.OneWayCallback(It.IsAny <string>()))
.Callback((string input) =>
{
resetEvent.Set();
});
var proxy = WcfClientProxy.Create <IDuplexService>(c =>
{
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress, callback.Object);
});
proxy.OneWay("test");
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
{
Assert.Fail("Callback not entered");
}
}
public void Test()
{
var service = Substitute.For <ITestService>();
var serviceHost = InProcTestFactory.CreateHost <ITestService>(service);
Assert.DoesNotThrow(() => WcfClientProxy.Create <IIssue25Service>(
c => c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress)));
}
public void MockedService_WorksAsExpected()
{
var mockService = new Mock <ITestService>();
mockService
.Setup(m => m.TestMethod("known"))
.Returns("test");
var proxy = InProcTestFactory.CreateHostWithClientProxy <ITestService>(new TestServiceImpl(mockService));
Assert.That(() => proxy.TestMethod("known"), Is.EqualTo("test"));
}
public void FaultHappens_WithDefaultChannelProxy()
{
var mockService = new Mock <ITestService>();
mockService.Setup(m => m.TestMethod("good")).Returns("OK");
mockService.Setup(m => m.TestMethod("bad")).Throws <Exception>();
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = new ChannelFactory <ITestService>(serviceHost.Binding, serviceHost.EndpointAddress).CreateChannel();
// Will fault the channel
Assert.That(() => proxy.TestMethod("bad"), Throws.Exception);
Assert.That(() => proxy.TestMethod("good"), Throws.Exception.TypeOf <CommunicationObjectFaultedException>());
}
public void CallAsync_CanCallIntoSyncProxy()
{
var mockService = new Mock <ITestService>();
mockService
.Setup(m => m.TestMethod("good"))
.Returns("OK");
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
string result = proxy.Client.TestMethod("good");
Assert.That(result, Is.EqualTo("OK"));
}
public void CallAsync_CallingMethodWithByRefParams_ThrowsNotSupportedException()
{
var mockService = new Mock <IOutParamTestService>();
byte[] expectedOutParam = { 0x01 };
mockService
.Setup(m => m.SingleOutParam(out expectedOutParam))
.Returns(100);
var serviceHost = InProcTestFactory.CreateHost <IOutParamTestService>(new OutParamTestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <IOutParamTestService>(c =>
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress));
byte[] resultingOutParam;
Assert.That(() => proxy.CallAsync(m => m.SingleOutParam(out resultingOutParam)), Throws.TypeOf <NotSupportedException>());
}
public void DuplexService_OneWayOperation_TriggersCallback()
{
var resetEvent = new AutoResetEvent(false);
var serviceHost = InProcTestFactory.CreateHost <IDuplexService>(new DuplexService());
var callback = Substitute.For <IDuplexServiceCallback>();
callback
.When(m => m.OneWayCallback(Arg.Any <string>()))
.Do(_ => resetEvent.Set());
var proxy = WcfClientProxy.Create <IDuplexService>(c =>
{
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress, callback);
});
proxy.OneWay("test");
if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
{
Assert.Fail("Callback not entered");
}
}
public async Task CallAsync_MethodWithReturnValue2()
{
var request = new Request()
{
RequestMessage = "test"
};
var mockService = new Mock <ITestService>();
mockService
.SetupSequence(m => m.TestMethodComplex(It.IsAny <Request>()))
.Returns(new Response {
ResponseMessage = "test", StatusCode = 1
})
.Returns(new Response {
ResponseMessage = "test", StatusCode = 0
});
var serviceHost = InProcTestFactory.CreateHost <ITestService>(new TestServiceImpl(mockService));
var proxy = WcfClientProxy.CreateAsyncProxy <ITestService>(c =>
{
c.MaximumRetries(1);
c.SetEndpoint(serviceHost.Binding, serviceHost.EndpointAddress);
c.RetryOnResponse <Response>(s => s.StatusCode == 1);
});
Console.WriteLine("Caller thread: " + Thread.CurrentThread.ManagedThreadId);
var result = await proxy.CallAsync(m => m.TestMethodComplex(request));
Console.WriteLine("Continuation thread: " + Thread.CurrentThread.ManagedThreadId);
Assert.That(result.StatusCode, Is.EqualTo(0));
Assert.That(result.ResponseMessage, Is.EqualTo("test"));
}
