public static void DuplexClientBaseOfT_OverNetTcp_Synchronous_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid,
string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
((ICommunicationObject)duplexService).Close();
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public static void DuplexClientBaseOfT_OverNetTcp_Synchronous_Call()
{
DuplexClientBase <IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid,
string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
((ICommunicationObject)duplexService).Close();
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public static void DuplexClientBase_Aborts_Changes_CommunicationState()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(FakeAddress.TcpAddress);
MyDuplexClientBase<IWcfDuplexService> duplexClientBase = new MyDuplexClientBase<IWcfDuplexService>(context, binding, endpoint);
Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State);
duplexClientBase.Abort();
Assert.Equal<CommunicationState>(CommunicationState.Closed, duplexClientBase.State);
}
public static void DuplexClientBase_Aborts_Changes_CommunicationState()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(FakeAddress.TcpAddress);
MyDuplexClientBase <IWcfDuplexService> duplexClientBase = new MyDuplexClientBase <IWcfDuplexService>(context, binding, endpoint);
Assert.Equal <CommunicationState>(CommunicationState.Created, duplexClientBase.State);
duplexClientBase.Abort();
Assert.Equal <CommunicationState>(CommunicationState.Closed, duplexClientBase.State);
}
public static void DuplexClientBase_Ctor_Initializes_State()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address);
MyDuplexClientBase<IWcfDuplexService> duplexClientBase = new MyDuplexClientBase<IWcfDuplexService>(context, binding, endpoint);
Assert.Equal<EndpointAddress>(endpoint, duplexClientBase.Endpoint.Address);
Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State);
duplexClientBase.Abort();
}
public static void DuplexClientBaseOfT_OverNetTcp_Call()
{
DuplexClientBase <IWcfDuplexService> duplexService = null;
StringBuilder errorBuilder = new StringBuilder();
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
if (guid != returnedGuid)
{
errorBuilder.AppendLine(String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));
}
((ICommunicationObject)duplexService).Close();
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString()));
for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
{
errorBuilder.AppendLine(String.Format("Inner exception: {0}", innerException.ToString()));
}
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: DuplexClientBaseOfT_OverNetTcp_Call FAILED with the following errors: {0}", errorBuilder));
}
public static void DuplexClientBaseOfT_OverNetTcp_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
StringBuilder errorBuilder = new StringBuilder();
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
if (guid != returnedGuid)
{
errorBuilder.AppendLine(String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));
}
duplexService.Close();
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString()));
for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
{
errorBuilder.AppendLine(String.Format("Inner exception: {0}", innerException.ToString()));
}
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: DuplexClientBaseOfT_OverNetTcp_Call FAILED with the following errors: {0}", errorBuilder));
}
public static void TransportUsageAlways_WebSockets_Synchronous_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
NetHttpBinding binding = new NetHttpBinding();
binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
var uri = new Uri(Endpoints.HttpBaseAddress_NetHttpWebSocket);
UriBuilder builder = new UriBuilder(Endpoints.HttpBaseAddress_NetHttpWebSocket);
switch (uri.Scheme.ToLowerInvariant())
{
case "http":
builder.Scheme = "ws";
break;
case "https":
builder.Scheme = "wss";
break;
}
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(builder.Uri));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
proxy.Ping(guid);
//Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid,
string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
((ICommunicationObject)duplexService).Close();
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public static void DuplexClientBaseOfT_OverHttp_Call_Throws_InvalidOperation()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Https_DefaultBinding_Address));
var exception = Assert.Throws<InvalidOperationException>(() =>
{
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
});
// Can't compare the entire exception message - .NET Native doesn't necessarily output the entire message, just params
// "Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it"
Assert.True(exception.Message.Contains("BasicHttpBinding"));
Assert.Throws<CommunicationObjectFaultedException>(() =>
{
// You can't gracefully close a Faulted CommunicationObject, so we should make sure it throws here too
((ICommunicationObject)duplexService).Close();
});
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public static void DuplexClientBaseOfT_OverHttp_Call_Throws_InvalidOperation()
{
DuplexClientBase <IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Https_DefaultBinding_Address));
var exception = Assert.Throws <InvalidOperationException>(() =>
{
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
});
// Can't compare the entire exception message - .NET Native doesn't necessarily output the entire message, just params
// "Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it"
Assert.True(exception.Message.Contains("BasicHttpBinding"));
Assert.Throws <CommunicationObjectFaultedException>(() =>
{
// You can't gracefully close a Faulted CommunicationObject, so we should make sure it throws here too
((ICommunicationObject)duplexService).Close();
});
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}