public static void NetTcpBinding_DuplexCallback_ReturnsXmlComplexType() { DuplexChannelFactory<IWcfDuplexService_Xml> factory = null; NetTcpBinding binding = null; WcfDuplexServiceCallback callbackService = null; InstanceContext context = null; IWcfDuplexService_Xml serviceProxy = null; Guid guid = Guid.NewGuid(); try { binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; callbackService = new WcfDuplexServiceCallback(); context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService_Xml>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_XmlDuplexCallback_Address)); serviceProxy = factory.CreateChannel(); serviceProxy.Ping_Xml(guid); XmlCompositeTypeDuplexCallbackOnly returnedType = callbackService.XmlCallbackGuid; // validate response Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue)); ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory<IWcfDuplexService> factory = null; IWcfDuplexService duplexProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); duplexProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)duplexProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory); } }
public static void IOperationBehavior_Methods_AreCalled() { DuplexClientBase <ICustomOperationBehaviorDuplexService> duplexService = null; ICustomOperationBehaviorDuplexService proxy = null; NetTcpBinding binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); duplexService = new MyDuplexClientBase <ICustomOperationBehaviorDuplexService>(context, binding, new EndpointAddress(FakeAddress.TcpAddress)); proxy = duplexService.ChannelFactory.CreateChannel(); // Wait to validate until the process has been given a reasonable time to complete. Task[] taskCollection = { MyOperationBehavior.validateMethodTcs.Task, MyOperationBehavior.addBindingParametersMethodTcs.Task, MyOperationBehavior.applyClientBehaviorMethodTcs.Task }; bool waitAll = Task.WaitAll(taskCollection, 250); Assert.True(MyOperationBehavior.errorBuilder.Length == 0, "Test case FAILED with errors: " + MyOperationBehavior.errorBuilder.ToString()); Assert.True(waitAll, "None of the IOperationBehavior methods were called."); ((ICommunicationObject)proxy).Close(); ((ICommunicationObject)duplexService).Close(); }
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory <IWcfDuplexService> factory = null; IWcfDuplexService duplexProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); duplexProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)duplexProxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory); } }
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory<IWcfDuplexService> factory = null; Guid guid = Guid.NewGuid(); NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); try { factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); IWcfDuplexService duplexProxy = factory.CreateChannel(); Task.Run(() => duplexProxy.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)); } finally { if (factory != null && factory.State != CommunicationState.Closed) { factory.Abort(); } } }
public static void NetTcpBinding_DuplexCallback_ReturnsXmlComplexType() { DuplexChannelFactory <IWcfDuplexService_Xml> factory = null; NetTcpBinding binding = null; WcfDuplexServiceCallback callbackService = null; InstanceContext context = null; IWcfDuplexService_Xml serviceProxy = null; Guid guid = Guid.NewGuid(); try { binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; callbackService = new WcfDuplexServiceCallback(); context = new InstanceContext(callbackService); factory = new DuplexChannelFactory <IWcfDuplexService_Xml>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_XmlDuplexCallback_Address)); serviceProxy = factory.CreateChannel(); serviceProxy.Ping_Xml(guid); XmlCompositeTypeDuplexCallbackOnly returnedType = callbackService.XmlCallbackGuid; // validate response Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue)); ((ICommunicationObject)serviceProxy).Close(); factory.Close(); } finally { ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
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 RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid() { DuplexChannelFactory <IWcfDuplexService> factory = null; Guid guid = Guid.NewGuid(); NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); try { factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); IWcfDuplexService duplexProxy = factory.CreateChannel(); Task.Run(() => duplexProxy.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)); } finally { if (factory != null && factory.State != CommunicationState.Closed) { factory.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 CreateChannel_Of_IDuplexChannel_Using_NetTcpBinding_Creates_Unique_Instances() { DuplexChannelFactory <IWcfDuplexService> factory = null; DuplexChannelFactory <IWcfDuplexService> factory2 = null; IWcfDuplexService channel = null; IWcfDuplexService channel2 = null; WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); try { NetTcpBinding binding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpointAddress = new EndpointAddress(FakeAddress.TcpAddress); // Create the channel factory for the request-reply message exchange pattern. factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpointAddress); factory2 = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpointAddress); // Create the channel. channel = factory.CreateChannel(); Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel.GetType(), typeof(IDuplexChannel))); channel2 = factory2.CreateChannel(); Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel2.GetType(), typeof(IDuplexChannel))); // Validate ToString() string toStringResult = channel.ToString(); string toStringExpected = "IWcfDuplexService"; Assert.Equal <string>(toStringExpected, toStringResult); // Validate Equals() Assert.StrictEqual <IWcfDuplexService>(channel, channel); // Validate Equals(other channel) negative Assert.NotStrictEqual <IWcfDuplexService>(channel, channel2); // Validate Equals("other") negative Assert.NotStrictEqual <object>(channel, "other"); // Validate Equals(null) negative Assert.NotStrictEqual <IWcfDuplexService>(channel, null); } finally { if (factory != null) { factory.Close(); } if (factory2 != null) { factory2.Close(); } } }
public static void CreateChannel_Using_NetTcp_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }
public static void CreateChannel_EmptyEndpointAddress_AsString_ThrowsUriFormat() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws<UriFormatException>(() => { DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, string.Empty); }); }
// valid address, but the scheme is incorrect public static void CreateChannel_ExpectedNetTcpScheme_InvalidScheme_ThrowsUriFormat() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws<ArgumentException>("via", () => { DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, "qwerty://not-the-right-scheme"); factory.CreateChannel(); }); }
public static void CreateChannel_EmptyEndpointAddress_AsString_ThrowsUriFormat() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws <UriFormatException>(() => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, string.Empty); }); }
public static void CreateChannel_Address_NullString_ThrowsArgumentNull() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws <ArgumentNullException>("uri", () => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, (string)null); }); }
// valid address, but the scheme is incorrect public static void CreateChannel_ExpectedNetTcpScheme_InvalidScheme_ThrowsUriFormat() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws <ArgumentException>("via", () => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, "qwerty://not-the-right-scheme"); factory.CreateChannel(); }); }
public static void CreateChannel_Using_NetTcpBinding_Defaults() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); IWcfDuplexService proxy = factory.CreateChannel(); Assert.NotNull(proxy); }
public static void CreateChannel_Address_NullEndpointAddress_ThrowsArgumentNull() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, (EndpointAddress)null); Assert.Throws <InvalidOperationException>(() => { factory.CreateChannel(); }); }
public static void DuplexClientBaseOfT_OverHttp_Call_Throws_InvalidOperation() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); if (!root_Certificate_Installed) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); return; } #endif DuplexClientBase <IWcfDuplexService> duplexService = null; IWcfDuplexService proxy = null; try { // *** SETUP *** \\ 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)); // *** EXECUTE *** \\ var exception = Assert.Throws <InvalidOperationException>(() => { proxy = duplexService.ChannelFactory.CreateChannel(); }); // *** VALIDATE *** \\ // 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(); }); // *** CLEANUP *** \\ // proxy will be null here so can't close. // duplexService is closed prior to this as part of an assert to verify an expected exception. } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, duplexService); } }
public static void DuplexClientBaseOfT_OverHttp_Call_Throws_InvalidOperation() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); if (!root_Certificate_Installed) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); return; } #endif DuplexClientBase<IWcfDuplexService> duplexService = null; IWcfDuplexService proxy = null; try { // *** SETUP *** \\ 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)); // *** EXECUTE *** \\ var exception = Assert.Throws<InvalidOperationException>(() => { proxy = duplexService.ChannelFactory.CreateChannel(); }); // *** VALIDATE *** \\ // 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(); }); // *** CLEANUP *** \\ // proxy will be null here so can't close. // duplexService is closed prior to this as part of an assert to verify an expected exception. } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, duplexService); } }
public static void CreateChannel_Using_NetTcpBinding_Defaults() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); Assert.Throws <ArgumentNullException>("endpointAddress", () => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }); }
// Asking for ChainTrust only should succeed if the certificate is // chain-trusted. public static void NetTcp_SecModeTrans_Duplex_Callback_Succeeds() { string clientCertThumb = null; EndpointAddress endpointAddress = null; DuplexChannelFactory <IWcfDuplexService> factory = null; IWcfDuplexService serviceProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri( Endpoints.Tcp_Certificate_Duplex_Address)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust; factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ // Ping on another thread. Task.Run(() => serviceProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); ((ICommunicationObject)factory).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
// valid address, but the scheme is incorrect public static void CreateChannel_BasicHttpBinding_Throws_InvalidOperation() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new BasicHttpBinding(BasicHttpSecurityMode.None); // Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it. var exception = Assert.Throws <InvalidOperationException>(() => { DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, "http://basichttp-not-duplex"); factory.CreateChannel(); }); Assert.True(exception.Message.Contains("BasicHttpBinding"), string.Format("InvalidOperationException exception string should contain 'BasicHttpBinding'. Actual message:\r\n" + exception.ToString())); }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress); DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpoint); // Can't cast to IDuplexSessionChannel to IRequestChannel on http var exception = Assert.Throws <InvalidCastException>(() => { factory.CreateChannel(); }); // Can't check that the InvalidCastException message as .NET Native only reports this message for all InvalidCastExceptions: // "System.InvalidCastException: Arg_InvalidCastException" }
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 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 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; IWcfDuplexService proxy = null; try { // *** SETUP *** \\ 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)); // *** EXECUTE *** \\ var exception = Assert.Throws <InvalidOperationException>(() => { proxy = duplexService.ChannelFactory.CreateChannel(); }); // *** VALIDATE *** \\ // 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.Contains("BasicHttpBinding", exception.Message); Assert.Throws <CommunicationObjectFaultedException>(() => { // You can't gracefully close a Faulted CommunicationObject, so we should make sure it throws here too ((ICommunicationObject)duplexService).Close(); }); // *** CLEANUP *** \\ // proxy will be null here so can't close. // duplexService is closed prior to this as part of an assert to verify an expected exception. } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, duplexService); } }
public static void CreateChannel_EndpointAddress_Null_Throws() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress remoteAddress = null; DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, remoteAddress); try { Assert.Throws<InvalidOperationException>(() => { factory.Open(); factory.CreateChannel(); }); } finally { factory.Abort(); } }
public static void CreateChannel_EndpointAddress_Null_Throws() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress remoteAddress = null; DuplexChannelFactory <IWcfDuplexService> factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, remoteAddress); try { Assert.Throws <InvalidOperationException>(() => { factory.Open(); factory.CreateChannel(); }); } finally { factory.Abort(); } }
public static void WebSocket_WSScheme_WSTransportUsageAlways_DuplexCallback_GuidRoundtrip() { DuplexChannelFactory <IWcfDuplexService> factory = null; IWcfDuplexService proxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); UriBuilder builder = new UriBuilder(Endpoints.NetHttpWebSocketTransport_Address); // Replacing "http" with "ws" as the uri scheme. builder.Scheme = "ws"; factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); proxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => proxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)proxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, factory); } }
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_OverNetTcp_Synchronous_Call() { DuplexClientBase <IWcfDuplexService> duplexService = null; IWcfDuplexService proxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ 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)); proxy = duplexService.ChannelFactory.CreateChannel(); // *** EXECUTE *** \\ // Ping on another thread. Task.Run(() => proxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)duplexService).Close(); ((ICommunicationObject)proxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, (ICommunicationObject)duplexService); } }
public static void DuplexClientBaseOfT_OverNetTcp_Synchronous_Call() { DuplexClientBase<IWcfDuplexService> duplexService = null; IWcfDuplexService proxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ 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)); proxy = duplexService.ChannelFactory.CreateChannel(); // *** EXECUTE *** \\ // Ping on another thread. Task.Run(() => proxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)duplexService).Close(); ((ICommunicationObject)proxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, (ICommunicationObject)duplexService); } }
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 WebSocket_Http_WSTransportUsageDefault_DuplexCallback_GuidRoundtrip() { DuplexChannelFactory <IWcfDuplexService> factory = null; IWcfDuplexService duplexProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); // NetHttpBinding default value of WebSocketTransportSettings.WebSocketTransportUsage is "WhenDuplex" // Therefore using a Duplex Contract will trigger the use of the WCF implementation of WebSockets. WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpDuplexWebSocket_Address)); duplexProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)duplexProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory); } }
public static void IOperationBehavior_Methods_AreCalled() { DuplexClientBase<ICustomOperationBehaviorDuplexService> duplexService = null; ICustomOperationBehaviorDuplexService proxy = null; NetTcpBinding binding = new NetTcpBinding(); binding.Security.Mode = SecurityMode.None; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); duplexService = new MyDuplexClientBase<ICustomOperationBehaviorDuplexService>(context, binding, new EndpointAddress(FakeAddress.TcpAddress)); proxy = duplexService.ChannelFactory.CreateChannel(); // Wait to validate until the process has been given a reasonable time to complete. Task[] taskCollection = { MyOperationBehavior.validateMethodTcs.Task, MyOperationBehavior.addBindingParametersMethodTcs.Task, MyOperationBehavior.applyClientBehaviorMethodTcs.Task }; bool waitAll = Task.WaitAll(taskCollection, 250); Assert.True(MyOperationBehavior.errorBuilder.Length == 0, "Test case FAILED with errors: " + MyOperationBehavior.errorBuilder.ToString()); Assert.True(waitAll, "None of the IOperationBehavior methods were called."); ((ICommunicationObject)proxy).Close(); ((ICommunicationObject)duplexService).Close(); }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(Endpoints.HttpBaseAddress_NetHttp); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); // Can't cast to IDuplexSessionChannel to IRequestChannel on http var exception = Assert.Throws<InvalidCastException>(() => { factory.CreateChannel(); }); Assert.True(exception.Message.Contains("IRequestChannel"), "InvalidCastException exception string should contain 'IRequestChannel'"); }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }
public static void CreateChannel_Of_IDuplexChannel_Using_NetTcpBinding_Creates_Unique_Instances() { DuplexChannelFactory<IWcfDuplexService> factory = null; DuplexChannelFactory<IWcfDuplexService> factory2 = null; IWcfDuplexService channel = null; IWcfDuplexService channel2 = null; WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); try { NetTcpBinding binding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpointAddress = new EndpointAddress(FakeAddress.TcpAddress); // Create the channel factory for the request-reply message exchange pattern. factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpointAddress); factory2 = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpointAddress); // Create the channel. channel = factory.CreateChannel(); Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel.GetType(), typeof(IDuplexChannel))); channel2 = factory2.CreateChannel(); Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()), String.Format("Channel type '{0}' was not assignable to '{1}'", channel2.GetType(), typeof(IDuplexChannel))); // Validate ToString() string toStringResult = channel.ToString(); string toStringExpected = "IWcfDuplexService"; Assert.Equal<string>(toStringExpected, toStringResult); // Validate Equals() Assert.StrictEqual<IWcfDuplexService>(channel, channel); // Validate Equals(other channel) negative Assert.NotStrictEqual<IWcfDuplexService>(channel, channel2); // Validate Equals("other") negative Assert.NotStrictEqual<object>(channel, "other"); // Validate Equals(null) negative Assert.NotStrictEqual<IWcfDuplexService>(channel, null); } finally { if (factory != null) { factory.Close(); } if (factory2 != null) { factory2.Close(); } } }
public static void CreateChannel_Using_NetTcpBinding_Defaults() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); IWcfDuplexService proxy = factory.CreateChannel(); Assert.NotNull(proxy); }
public static void CreateChannel_Using_NetTcp_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(SecurityMode.None); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }
public static void CreateChannel_Address_NullString_ThrowsArgumentNull() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); Assert.Throws<ArgumentNullException>("uri", () => { DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, (string)null); }); }
public static void CreateChannel_Address_NullEndpointAddress_ThrowsArgumentNull() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, (EndpointAddress)null); Assert.Throws<InvalidOperationException>(() => { factory.CreateChannel(); }); }
public static void CreateChannel_Using_NetTcpBinding_Defaults() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetTcpBinding(); EndpointAddress endpoint = new EndpointAddress("net.tcp://not-an-endpoint"); Assert.Throws<ArgumentNullException>("endpointAddress", () => { DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); factory.CreateChannel(); }); }
public static void WebSocket_Http_WSTransportUsageDefault_DuplexCallback_GuidRoundtrip() { DuplexChannelFactory<IWcfDuplexService> factory = null; IWcfDuplexService duplexProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); // NetHttpBinding default value of WebSocketTransportSettings.WebSocketTransportUsage is "WhenDuplex" // Therefore using a Duplex Contract will trigger the use of the WCF implementation of WebSockets. WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpDuplexWebSocket_Address)); duplexProxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => duplexProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)duplexProxy).Close(); factory.Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory); } }
// valid address, but the scheme is incorrect public static void CreateChannel_BasicHttpBinding_Throws_InvalidOperation() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new BasicHttpBinding(BasicHttpSecurityMode.None); // Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it. var exception = Assert.Throws<InvalidOperationException>(() => { DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, "http://basichttp-not-duplex"); factory.CreateChannel(); }); Assert.True(exception.Message.Contains("BasicHttpBinding"), string.Format("InvalidOperationException exception string should contain 'BasicHttpBinding'. Actual message:\r\n" + exception.ToString())); }
// Asking for ChainTrust only should succeed if the certificate is // chain-trusted. public static void NetTcp_SecModeTrans_Duplex_Callback_Succeeds() { #if FULLXUNIT_NOTSUPPORTED bool root_Certificate_Installed = Root_Certificate_Installed(); bool client_Certificate_Installed = Client_Certificate_Installed(); bool ssl_Available = SSL_Available(); if (!root_Certificate_Installed || !client_Certificate_Installed || !ssl_Available) { Console.WriteLine("---- Test SKIPPED --------------"); Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE."); Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed); Console.WriteLine("Client_Certificate_Installed evaluated as {0}", client_Certificate_Installed); Console.WriteLine("SSL_Available evaluated as {0}", ssl_Available); return; } #endif string clientCertThumb = null; EndpointAddress endpointAddress = null; DuplexChannelFactory <IWcfDuplexService> factory = null; IWcfDuplexService serviceProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri( Endpoints.Tcp_Certificate_Duplex_Address)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory <IWcfDuplexService>(context, binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust; factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ // Ping on another thread. Task.Run(() => serviceProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); ((ICommunicationObject)factory).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void CreateChannel_Using_Http_NoSecurity() { WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callback); Binding binding = new NetHttpBinding(BasicHttpSecurityMode.None); EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress); DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpoint); // Can't cast to IDuplexSessionChannel to IRequestChannel on http var exception = Assert.Throws<InvalidCastException>(() => { factory.CreateChannel(); }); // Can't check that the InvalidCastException message as .NET Native only reports this message for all InvalidCastExceptions: // "System.InvalidCastException: Arg_InvalidCastException" }
// Asking for ChainTrust only should succeed if the certificate is // chain-trusted. public static void NetTcp_SecModeTrans_Duplex_Callback_Succeeds() { string clientCertThumb = null; EndpointAddress endpointAddress = null; DuplexChannelFactory<IWcfDuplexService> factory = null; IWcfDuplexService serviceProxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetTcpBinding binding = new NetTcpBinding(SecurityMode.Transport); binding.Security.Transport.ClientCredentialType = TcpClientCredentialType.Certificate; endpointAddress = new EndpointAddress(new Uri( Endpoints.Tcp_Certificate_Duplex_Address)); clientCertThumb = ServiceUtilHelper.ClientCertificate.Thumbprint; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, endpointAddress); factory.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.ChainTrust; factory.Credentials.ClientCertificate.SetCertificate( StoreLocation.CurrentUser, StoreName.My, X509FindType.FindByThumbprint, clientCertThumb); serviceProxy = factory.CreateChannel(); // *** EXECUTE *** \\ // Ping on another thread. Task.Run(() => serviceProxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ ((ICommunicationObject)serviceProxy).Close(); ((ICommunicationObject)factory).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory); } }
public static void WebSocket_WSScheme_WSTransportUsageAlways_DuplexCallback_GuidRoundtrip() { DuplexChannelFactory<IWcfDuplexService> factory = null; IWcfDuplexService proxy = null; Guid guid = Guid.NewGuid(); try { // *** SETUP *** \\ NetHttpBinding binding = new NetHttpBinding(); binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always; WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback(); InstanceContext context = new InstanceContext(callbackService); UriBuilder builder = new UriBuilder(Endpoints.NetHttpWebSocketTransport_Address); // Replacing "http" with "ws" as the uri scheme. builder.Scheme = "ws"; factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address)); proxy = factory.CreateChannel(); // *** EXECUTE *** \\ Task.Run(() => proxy.Ping(guid)); Guid returnedGuid = callbackService.CallbackGuid; // *** VALIDATE *** \\ Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); // *** CLEANUP *** \\ factory.Close(); ((ICommunicationObject)proxy).Close(); } finally { // *** ENSURE CLEANUP *** \\ ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, factory); } }