Fix OneWay only contracts with ReliableSessions

src/System.Private.ServiceModel/src/System/ServiceModel/Channels/ReliableOutputSessionChannel.cs

@@ -330,6 +330,26 @@ protected override void OnOpen(TimeSpan timeout)
             CommunicationObjectInternal.OnOpen(this, timeout);
         }
 
+        protected internal override async Task OnOpenAsync(TimeSpan timeout)
+        {
+            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
+            bool throwing = true;
+
+            try
+            {
+                await _binder.OpenAsync(timeoutHelper.RemainingTime());
+                await _session.OpenAsync(timeoutHelper.RemainingTime());
+                throwing = false;
+            }
+            finally
+            {
+                if (throwing)
+                {
+                    await Binder.CloseAsync(timeoutHelper.RemainingTime());
+                }
+            }
+        }
+
         protected override async Task OnSendAsync(Message message, TimeSpan timeout)
         {
             if (!await Connection.AddMessageAsync(message, timeout, null))

src/System.Private.ServiceModel/tests/Common/Scenarios/Endpoints.cs

@@ -144,11 +144,21 @@ public static string ReliableSession_NetHttp
         get { return GetEndpointAddress("ReliableSessionService.svc/NetHttp"); }
     }
 
+    public static string ReliableOneWaySession_NetHttp
+    {
+        get { return GetEndpointAddress("ReliableSessionOneWayService.svc/NetHttp"); }
+    }
+
     public static string ReliableSession_WSHttp
     {
         get { return GetEndpointAddress("ReliableSessionService.svc/WSHttp"); }
     }
 
+    public static string ReliableOneWaySession_WSHttp
+    {
+        get { return GetEndpointAddress("ReliableSessionOneWayService.svc/WSHttp"); }
+    }
+
     #region WebSocket Addresses
     public static string HttpBaseAddress_NetHttpWebSockets
     {
@@ -734,6 +744,11 @@ public static string ReliableSession_NetTcp
         get { return GetEndpointAddress("ReliableSessionService.svc/NetTcp", protocol: "net.tcp"); }
     }
 
+    public static string ReliableOneWaySession_NetTcp
+    {
+        get { return GetEndpointAddress("ReliableSessionOneWayService.svc/NetTcp", protocol: "net.tcp"); }
+    }
+
     public static string ReliableDuplexSession_NetTcp
     {
         get { return GetEndpointAddress("ReliableSessionDuplexService.svc/NetTcp", protocol: "net.tcp"); }

src/System.Private.ServiceModel/tests/Common/Scenarios/ServiceInterfaces.cs

@@ -854,6 +854,13 @@ public interface IWcfReliableService
     Task<string> EchoAsync(string echo);
 }
 
+[ServiceContract]
+public interface IOneWayWcfReliableService
+{
+    [OperationContract(IsOneWay = true)]
+    Task OneWayAsync(string text);
+}
+
 [ServiceContract(CallbackContract = typeof(IWcfReliableDuplexService))]
 public interface IWcfReliableDuplexService
 {

src/System.Private.ServiceModel/tests/Scenarios/Binding/ReliableSession/NetHttpBindingTests.cs

@@ -54,6 +54,43 @@ public static async Task EchoCall(ReliableMessagingVersion rmVersion, bool order
         }
     }
 
+    [WcfTheory]
+    [MemberData(nameof(GetTestVariations))]
+    [OuterLoop]
+    public static async Task OneWayCall(ReliableMessagingVersion rmVersion, bool ordered, string endpointSuffix)
+    {
+        string testString = "Hello";
+        ChannelFactory<IOneWayWcfReliableService> factory = null;
+        IOneWayWcfReliableService serviceProxy = null;
+        NetHttpBinding binding = null;
+
+        try
+        {
+            // *** SETUP *** \\
+            binding = new NetHttpBinding(BasicHttpSecurityMode.None, true);
+            binding.ReliableSession.Ordered = ordered;
+            var customBinding = new CustomBinding(binding);
+            var reliableSessionBindingElement = customBinding.Elements.Find<ReliableSessionBindingElement>();
+            reliableSessionBindingElement.ReliableMessagingVersion = rmVersion;
+            factory = new ChannelFactory<IOneWayWcfReliableService>(customBinding, new EndpointAddress(Endpoints.ReliableOneWaySession_NetHttp + endpointSuffix));
+            serviceProxy = factory.CreateChannel();
+            // *** EXECUTE *** \\
+            ((IClientChannel)serviceProxy).Open(); // This will establish a reliable session
+            await serviceProxy.OneWayAsync(testString);
+            // *** VALIDATE *** \\
+
+            // *** CLEANUP *** \\
+            ((IClientChannel)serviceProxy).Close();
+            factory.Close();
+            ((ICommunicationObject)serviceProxy).Close();
+        }
+        finally
+        {
+            // *** ENSURE CLEANUP *** \\
+            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
+        }
+    }
+
     [WcfTheory]
     [MemberData(nameof(GetTestVariations))]
     [OuterLoop]

src/System.Private.ServiceModel/tests/Scenarios/Binding/ReliableSession/NetTcpBindingTests.cs

@@ -48,6 +48,42 @@ public static async Task EchoCall(ReliableMessagingVersion rmVersion, bool order
         }
     }
 
+    [WcfTheory]
+    [MemberData(nameof(GetTestVariations))]
+    [OuterLoop]
+    public static async Task OneWayCall(ReliableMessagingVersion rmVersion, bool ordered, string endpointSuffix)
+    {
+        string testString = "Hello";
+        ChannelFactory<IOneWayWcfReliableService> factory = null;
+        IOneWayWcfReliableService serviceProxy = null;
+        NetTcpBinding binding = null;
+
+        try
+        {
+            // *** SETUP *** \\
+            binding = new NetTcpBinding(SecurityMode.None, true);
+            binding.ReliableSession.Ordered = ordered;
+            var customBinding = new CustomBinding(binding);
+            var reliableSessionBindingElement = customBinding.Elements.Find<ReliableSessionBindingElement>();
+            reliableSessionBindingElement.ReliableMessagingVersion = rmVersion;
+            factory = new ChannelFactory<IOneWayWcfReliableService>(customBinding, new EndpointAddress(Endpoints.ReliableOneWaySession_NetTcp + endpointSuffix));
+            serviceProxy = factory.CreateChannel();
+            // *** EXECUTE *** \\
+            ((IClientChannel)serviceProxy).Open(); // This will establish a reliable session
+            await serviceProxy.OneWayAsync(testString);
+            // *** VALIDATE *** \\
+
+            // *** CLEANUP *** \\
+            ((IClientChannel)serviceProxy).Close();
+            factory.Close();
+        }
+        finally
+        {
+            // *** ENSURE CLEANUP *** \\
+            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
+        }
+    }
+
     [WcfTheory]
     [MemberData(nameof(GetTestVariations))]
     [OuterLoop]

src/System.Private.ServiceModel/tests/Scenarios/Binding/ReliableSession/WSHttpBindingTests.cs

@@ -54,6 +54,43 @@ public static async Task EchoCall(ReliableMessagingVersion rmVersion, bool order
         }
     }
 
+    [WcfTheory]
+    [MemberData(nameof(GetTestVariations))]
+    [OuterLoop]
+    public static async Task OneWayCall(ReliableMessagingVersion rmVersion, bool ordered, string endpointSuffix)
+    {
+        string testString = "Hello";
+        ChannelFactory<IOneWayWcfReliableService> factory = null;
+        IOneWayWcfReliableService serviceProxy = null;
+        WSHttpBinding binding = null;
+
+        try
+        {
+            // *** SETUP *** \\
+            binding = new WSHttpBinding(SecurityMode.None, true);
+            binding.ReliableSession.Ordered = ordered;
+            var customBinding = new CustomBinding(binding);
+            var reliableSessionBindingElement = customBinding.Elements.Find<ReliableSessionBindingElement>();
+            reliableSessionBindingElement.ReliableMessagingVersion = rmVersion;
+            factory = new ChannelFactory<IOneWayWcfReliableService>(customBinding, new EndpointAddress(Endpoints.ReliableOneWaySession_WSHttp + endpointSuffix));
+            serviceProxy = factory.CreateChannel();
+            // *** EXECUTE *** \\
+            ((IClientChannel)serviceProxy).Open(); // This will establish a reliable session
+            await serviceProxy.OneWayAsync(testString);
+            // *** VALIDATE *** \\
+
+            // *** CLEANUP *** \\
+            ((IClientChannel)serviceProxy).Close();
+            factory.Close();
+            ((ICommunicationObject)serviceProxy).Close();
+        }
+        finally
+        {
+            // *** ENSURE CLEANUP *** \\
+            ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
+        }
+    }
+
     [WcfTheory]
     [MemberData(nameof(GetTestVariations))]
     [OuterLoop]

src/System.Private.ServiceModel/tools/IISHostedWcfService/App_code/IWcfReliableService.cs

@@ -15,6 +15,13 @@ public interface IWcfReliableService
         string Echo(string echo);
     }
 
+    [ServiceContract]
+    public interface IOneWayWcfReliableService
+    {
+        [OperationContract(IsOneWay = true)]
+        void OneWay(string text);
+    }
+
     [ServiceContract(CallbackContract = typeof(IWcfReliableDuplexService))]
     public interface IWcfReliableDuplexService
     {

src/System.Private.ServiceModel/tools/IISHostedWcfService/App_code/WcfReliableService.cs

@@ -8,7 +8,7 @@
 namespace WcfService
 {
     [ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple, InstanceContextMode = InstanceContextMode.PerSession)]
-    public class WcfReliableService : IWcfReliableService, IWcfReliableDuplexService
+    public class WcfReliableService : IWcfReliableService, IWcfReliableDuplexService, IOneWayWcfReliableService
     {
         private int _currentNumber = 0;
 
@@ -27,5 +27,10 @@ public string DuplexEcho(string echo)
             var callback = OperationContext.Current.GetCallbackChannel<IWcfReliableDuplexService>();
             return callback.DuplexEcho(echo);
         }
+
+        public void OneWay(string text)
+        {
+            return;
+        }
     }
 }

src/System.Private.ServiceModel/tools/IISHostedWcfService/App_code/testhosts/ReliableSessionDuplexTestServiceHost.cs

@@ -10,7 +10,7 @@
 namespace WcfService
 {
     [TestServiceDefinition(BasePath = "ReliableSessionDuplexService.svc", Schema = ServiceSchema.NETTCP)]
-    public class ReliableSessionDuplexSerivceHost : TestServiceHostBase<IWcfReliableDuplexService>
+    public class ReliableSessionDuplexServiceHost : TestServiceHostBase<IWcfReliableDuplexService>
     {
         protected override IList<Binding> GetBindings()
         {
@@ -37,7 +37,7 @@ private void AddBinding(List<Binding> bindingList, Binding binding, bool ordered
             bindingList.Add(customBinding);
         }
 
-        public ReliableSessionDuplexSerivceHost(params Uri[] baseAddresses)
+        public ReliableSessionDuplexServiceHost(params Uri[] baseAddresses)
             : base(typeof(WcfReliableService), baseAddresses)
         {
         }

src/System.Private.ServiceModel/tools/IISHostedWcfService/App_code/testhosts/ReliableSessionOneWayTestServiceHost.cs

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.ServiceModel;
+using System.ServiceModel.Channels;
+
+namespace WcfService
+{
+    [TestServiceDefinition(BasePath = "ReliableSessionOneWayService.svc", Schema = ServiceSchema.HTTP | ServiceSchema.NETTCP)]
+    public class ReliableSessionOneWaySerivceHost : TestServiceHostBase<IOneWayWcfReliableService>
+    {
+        protected override IList<Binding> GetBindings()
+        {
+            var bindings = new List<Binding>();
+            AddBindings(bindings, new NetHttpBinding(BasicHttpSecurityMode.None, true), "NetHttp");
+            AddBindings(bindings, new NetTcpBinding(SecurityMode.None, true), "NetTcp");
+            AddBindings(bindings, new WSHttpBinding(SecurityMode.None, true), "WSHttp");
+            return bindings;
+        }
+
+        private void AddBindings(List<Binding> bindingList, Binding binding, string baseName)
+        {
+            AddBinding(bindingList, binding, true, ReliableMessagingVersion.WSReliableMessaging11, baseName);
+            AddBinding(bindingList, binding, false, ReliableMessagingVersion.WSReliableMessaging11, baseName);
+            AddBinding(bindingList, binding, true, ReliableMessagingVersion.WSReliableMessagingFebruary2005, baseName);
+            AddBinding(bindingList, binding, false, ReliableMessagingVersion.WSReliableMessagingFebruary2005, baseName);
+        }
+
+        private void AddBinding(List<Binding> bindingList, Binding binding, bool ordered, ReliableMessagingVersion rmVersion, string baseName)
+        {
+            var customBinding = new CustomBinding(binding);
+            var reliableSessionBindingElement = customBinding.Elements.Find<ReliableSessionBindingElement>();
+            reliableSessionBindingElement.Ordered = ordered;
+            reliableSessionBindingElement.ReliableMessagingVersion = rmVersion;
+            customBinding.Name = baseName + (ordered ? "Ordered" : "Unordered") + "_" + rmVersion.ToString();
+            bindingList.Add(customBinding);
+        }
+
+        public ReliableSessionOneWaySerivceHost(params Uri[] baseAddresses)
+            : base(typeof(WcfReliableService), baseAddresses)
+        {
+        }
+    }
+}