Made XmlTransport public and fixed some bugs.

By making XmlTransport public, one can now use the second GatewayClient constructor to specify a custom endpoint or transport.
Also improved documentation, removed an unused constant, and added some unit tests.

Author: fmelink

LinkMobility.PSWin.Client.Tests/EnumerableBatchExtensionTests.cs

@@ -0,0 +1,92 @@
+using LinkMobility.PSWin.Client.Extensions;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace LinkMobility.PSWin.Client.Tests
+{
+    [TestFixture]
+    public class EnumerableBatchExtensionTests
+    {
+        [Test]
+        public void Test_zero_batch_size()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => new int[2].Batch(0).ToArray());
+        }
+
+        [Test]
+        public void Test_MultipleEnumerationChecker()
+        {
+            var checker = new MultipleEnumerationChecker();
+            var items = checker.GetItems(10);
+            Assume.That(items.Count(), Is.EqualTo(items.Count()));
+            Assert.That(checker.Enumerations, Is.EqualTo(2), "Detected enumerations");
+        }
+
+        [Test]
+        public void Test_no_multiple_enumeration()
+        {
+            var checker = new MultipleEnumerationChecker();
+            var items = checker.GetItems(30);
+            
+            var iteratedItems = 0;
+            foreach (var batch in items.Batch(10))
+                foreach (var item in batch)
+                    iteratedItems++;
+
+            Assume.That(iteratedItems, Is.GreaterThan(0));
+            Assert.That(checker.Enumerations, Is.EqualTo(1), "Enumerations");
+        }
+
+        [Test]
+        public void Test_zero_batches()
+        {
+            var items = new int[0];
+            var batch = items.Batch(10);
+            Assert.That(batch, Is.Empty, "Number of batches");
+        }
+
+        [Test]
+        [TestCase(1)]
+        [TestCase(9)]
+        [TestCase(10)]
+        public void Test_one_batch(int itemCount)
+        {
+            var items = Enumerable.Range(0, itemCount).ToArray();
+            var batches = items.Batch(10);
+            var enumerator = batches.GetEnumerator();
+            Assert.That(enumerator.MoveNext(), Is.True, "At least one batch");
+            Assert.That(enumerator.Current, Is.EqualTo(Enumerable.Range(0, itemCount)), "Batch content");
+            Assert.That(enumerator.MoveNext(), Is.False, "No second batch");
+        }
+
+        [Test]
+        [TestCase(11)]
+        [TestCase(19)]
+        [TestCase(20)]
+        public void Test_two_batches(int itemCount)
+        {
+            var items = Enumerable.Range(0, itemCount).ToArray();
+            var batches = items.Batch(10);
+            var enumerator = batches.GetEnumerator();
+            Assert.That(enumerator.MoveNext(), Is.True, "At least one batch");
+            Assert.That(enumerator.Current, Is.EqualTo(Enumerable.Range(0, 10)), "First batch content");
+            Assert.That(enumerator.MoveNext(), Is.True, "At least two batches");
+            Assert.That(enumerator.Current, Is.EqualTo(Enumerable.Range(10, itemCount - 10)), "Second batch content");
+            Assert.That(enumerator.MoveNext(), Is.False, "No third batch");
+        }
+
+        public class MultipleEnumerationChecker
+        {
+            public int Enumerations { get; private set; } = 0;
+
+            public IEnumerable<int> GetItems(int count)
+            {
+                Enumerations++;
+                for (var i = 0; i < count; i++)
+                    yield return i;
+            }
+        }
+    }
+}

LinkMobility.PSWin.Client.Tests/LinkMobility.PSWin.Client.Tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="NUnit" Version="3.13.2" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PSWin.Client\LinkMobility.PSWin.Client.csproj" />
+  </ItemGroup>
+
+</Project>

LinkMobility.PsWin.Client.sln

@@ -9,7 +9,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Example.Client", "Example.C
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LinkMobility.PSWin.Receiver", "PSWin.Receiver\LinkMobility.PSWin.Receiver.csproj", "{3F783F0E-D2E1-4442-BBB1-80C67B3E0846}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Example.Receiver", "Example.Receiver\Example.Receiver.csproj", "{38C3F27E-2C39-4F82-9FA5-8038C359A89E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Example.Receiver", "Example.Receiver\Example.Receiver.csproj", "{38C3F27E-2C39-4F82-9FA5-8038C359A89E}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LinkMobility.PSWin.Client.Tests", "LinkMobility.PSWin.Client.Tests\LinkMobility.PSWin.Client.Tests.csproj", "{ADB9FBA1-3DC0-4C5F-AB53-11E1732E74E2}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -33,6 +35,10 @@ Global
 		{38C3F27E-2C39-4F82-9FA5-8038C359A89E}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{38C3F27E-2C39-4F82-9FA5-8038C359A89E}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{38C3F27E-2C39-4F82-9FA5-8038C359A89E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{ADB9FBA1-3DC0-4C5F-AB53-11E1732E74E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{ADB9FBA1-3DC0-4C5F-AB53-11E1732E74E2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{ADB9FBA1-3DC0-4C5F-AB53-11E1732E74E2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{ADB9FBA1-3DC0-4C5F-AB53-11E1732E74E2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

PSWin.Client/GatewayClient.cs

@@ -7,26 +7,66 @@
 
 namespace LinkMobility.PSWin.Client
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public class GatewayClient
     {
-        public const uint BatchSize = 150;
-
         private readonly ITransport transport;
 
+        /// <summary>
+        /// Initializes a client that sends messages using the default endpoint and transport.
+        /// </summary>
+        /// <param name="username">The username assigned to you by Link Mobility.</param>
+        /// <param name="password">The password assigned to you by Link Mobility.</param>
         public GatewayClient(string username, string password) : this(new XmlTransport(username, password))
         {
         }
 
+        /// <summary>
+        /// Initialize a client using the given transport.
+        /// </summary>
+        /// <param name="transport">The transport to use.</param>
         public GatewayClient(ITransport transport)
         {
             this.transport = transport;
         }
 
+        /// <summary>
+        /// Send a single message.
+        /// Using <see cref="SendAsync(IEnumerable{Sms}, string)"/> is more efficient if you need to send multiple messages.
+        /// </summary>
+        /// <seealso cref="SendAsync(IEnumerable{Sms}, string)"/>
+        /// <param name="message">The message to send.</param>
+        /// <param name="sessionData">See <see cref="SendAsync(IEnumerable{Sms}, string)"/>.</param>
+        /// <returns>See <see cref="SendAsync(IEnumerable{Sms}, string)"/>.</returns>
         public async Task<MessageResult> SendAsync(Sms message, string sessionData = null)
         {
             return (await transport.SendAsync(new Sms[] { message }, sessionData)).Single();
         }
 
+        /// <summary>
+        /// Send multiple Sms messages to the endpoint and retreive the results.
+        /// </summary>
+        /// <seealso cref="SendAsync(Sms, string)"/>
+        /// <param name="messages">
+        ///     The messages to send.
+        ///     Messages are automatically split into batches to avoid hitting the POST body size limit.
+        ///     It is however not recommended that you send large message bulks with this client.
+        ///     If you need to do so, please contact support instead.
+        /// </param>
+        /// <param name="sessionData">
+        ///     A free text field that can be used to tag the session with customer specific data such as the application name, username, reference-id etc.
+        ///     The maximum length is 200 characters.
+        ///     Leave empty unless required.
+        ///     If you need aggregated reports based on Session Data values​​, please contact support to get this enabled.
+        /// </param>
+        /// <returns>
+        ///     The immediate response to the sent messages, in the same order as <paramref name="messages"/>.
+        ///     The response does not indicate whether the message was actually delivered.
+        ///     To get delivery status you need to have delivery reports enabled on your account,
+        ///     and receive them with LinkMobility.PSWin.Receiver.
+        /// </returns>
         public async Task<IEnumerable<MessageResult>> SendAsync(IEnumerable<Sms> messages, string sessionData = null)
         {
             return await transport.SendAsync(messages, sessionData);

PSWin.Client/Interfaces/ITransport.cs

@@ -4,8 +4,20 @@
 
 namespace LinkMobility.PSWin.Client.Interfaces
 {
+    /// <summary>
+    /// The interface for an implementation of a PSWin gateway API.
+    /// </summary>
     public interface ITransport
     {
+        /// <summary>
+        /// Send text messages to the API that this transport implements.
+        /// </summary>
+        /// <param name="messageBatch">The messages to send.</param>
+        /// <param name="sessionData">
+        ///     A free text field that can be used to tag the session/messages with customer specific data such as the application name, username, reference-id etc.
+        ///     The maximum length is 200 characters.
+        /// </param>
+        /// <returns>A <see cref="MessageResult"/> for each message in <paramref name="messageBatch"/>, in the same order.</returns>
         Task<IEnumerable<MessageResult>> SendAsync(IEnumerable<Sms> messageBatch, string sessionData);
     }
 }

PSWin.Client/LinkMobility.PSWin.Client.csproj

@@ -18,6 +18,12 @@
     <PackageId>LinkMobilityNE.PSWin.Client</PackageId>
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
   </PropertyGroup>
+  
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+      <_Parameter1>$(AssemblyName).Tests</_Parameter1>
+    </AssemblyAttribute>
+  </ItemGroup>
 
   <ItemGroup>
     <None Include="..\linklogo128.png">

PSWin.Client/Model/MessageResult.cs

@@ -1,7 +1,13 @@
 namespace LinkMobility.PSWin.Client.Model
 {
+    /// <summary>
+    /// The response from sending a message to the PSWin gateway.
+    /// </summary>
     public class MessageResult
     {
+        /// <summary>
+        /// Initialize all the fields of the response.
+        /// </summary>
         public MessageResult(string gatewayReference, bool isStatusOk, string statusText, Sms message)
         {
             this.GatewayReference = gatewayReference;
@@ -10,9 +16,30 @@ public MessageResult(string gatewayReference, bool isStatusOk, string statusText
             this.Message = message;
         }
 
+        /// <summary>
+        /// The unique ID assigned to the message by the gateway,
+        /// if references are enabled on the account.
+        /// Otherwise null.
+        /// The same reference is included in delivery reports.
+        /// </summary>
         public string GatewayReference { get; }
+
+        /// <summary>
+        /// The message passed initial checks and was sent further down the pipeline.
+        /// Does not indicate whether the message actually was or could be delivered.
+        /// This information is available through delivery reports.
+        /// </summary>
         public bool IsStatusOk { get; }
+
+        /// <summary>
+        /// When <see cref="IsStatusOk"/> is false,
+        /// this contains a short description of the problem.
+        /// </summary>
         public string StatusText { get; }
+
+        /// <summary>
+        /// The message that this result belongs to.
+        /// </summary>
         public Sms Message { get; }
     }
 }

PSWin.Client/Model/Sms.cs

@@ -7,6 +7,13 @@ namespace LinkMobility.PSWin.Client.Model
     /// </summary>
     public class Sms
     {
+        /// <summary>
+        /// Initialize a text message and set the required properties.
+        /// There are a number of additional optional fields that can be set after the message is created.
+        /// </summary>
+        /// <param name="senderNumber">Sets the <see cref="SenderNumber"/> property.</param>
+        /// <param name="receiverNumber">Sets the <see cref="ReceiverNumber"/> property.</param>
+        /// <param name="text">Sets the <see cref="Text"/> property.</param>
         public Sms(string senderNumber, string receiverNumber, string text)
         {
             SenderNumber = senderNumber;
@@ -27,12 +34,14 @@ public Sms(string senderNumber, string receiverNumber, string text)
         ///         A string up to 11 characters long, containing only spaces and the following characters: A-Z, a-z, 0-9 and <![CDATA[!”#%&’()*+-./><;]]>
         ///     </description></item>
         /// </list>
+        /// May not be null.
         /// </summary>
         public string SenderNumber { get; set; }
 
         /// <summary>
         /// The receiver of the message.
         /// Must be a valid MSISDN. No spaces or international call prefix.
+        /// May not be null.
         /// </summary>
         public string ReceiverNumber { get; set; }
 
@@ -43,30 +52,35 @@ public Sms(string senderNumber, string receiverNumber, string text)
         /// Thus, the maximum length is 16*134=2144 characters. This is done automatically by the SMS Gateway.
         /// Text messages of more than 2144 characters will be truncated.
         /// Please note that only characters defined in the GSM-7 basic character set is allowed for messages of <see cref="Type"/> Text.
+        /// May not be null.
         /// </summary>
         public string Text { get; set; }
 
         /// <summary>
         /// Send a message as a Flash (a.k.a. Class 0) message.
+        /// Default is false.
         /// </summary>
         public bool IsFlashMessage { get; set; }
 
         /// <summary>
         /// Indicates a set of messages that can replace each other.
         /// This parameter can be used to specify that the message should replace a previous message with the same set-number in the Inbox of the handset.
+        /// Default is null.
         /// </summary>
         public Replace? Replace { get; set; }
 
         /// <summary>
-        /// The PSWinCom Gateway supports billing using mobile phones in Norway.
-        /// As opposed to traditional CPA/Premium SMS which can only be used to bill mobile content, CPA GAS can only be used to bill goods and services.
+        /// The PSWin gateway supports billing using mobile phones in Norway.
+        /// As opposed to traditional CPA/Premium SMS which can only be used to bill mobile content, this can only be used to bill goods and services (CPA GAS).
+        /// Default is null.
         /// </summary>
         public Payment Payment { get; set; }
 
         /// <summary>
         /// Specifies the number of minutes this message will be valid.
         /// The time is counted from the moment the message has been received and stored on PSWinCom Gateway.
         /// After the time has elapsed, the message will not be sent to the operator.
+        /// Default is null, which means the message is valid indefinitely.
         /// </summary>
         public TimeSpan? TimeToLive { get; set; }
 
@@ -75,15 +89,20 @@ public Sms(string senderNumber, string receiverNumber, string text)
         /// If this parameter is present the message will be considered to be a deferred message that will be queued for future delivery instead of immediately being forwarded to operator.
         /// Maximum delay of message is currently one week (7 days).
         /// The Gateway account must be provisioned to use this feature.
+        /// Default is null, which means the message is delivered as soon as possible.
         /// </summary>
         public DateTime? DeliveryTime { get; set; }
 
         /// <summary>
         /// The type of message content.
+        /// Default is null, which means the same as <see cref="MessageType.Text"/>. 
         /// </summary>
         public MessageType? Type { get; set; }
     }
 
+    /// <summary>
+    /// The type of message.
+    /// </summary>
     public enum MessageType
     {
         /// <summary>
@@ -98,15 +117,20 @@ public enum MessageType
         Unicode = 9,
     }
 
+    /// <summary>
+    /// The available replacement groups.
+    /// </summary>
     public enum Replace
     {
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
         Set1 = 1,
         Set2 = 2,
         Set3 = 3,
         Set4 = 4,
         Set5 = 5,
         Set6 = 6,
         Set7 = 7
+#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
     }
 }