mcs/class/System/Test/System.Net.WebSockets/ClientWebSocketTest.cs

   1 #if NET_4_5
   2 using System;
   3 using System.Net;
   4 using System.Threading;
   5 using System.Threading.Tasks;
   6 using System.Collections.Generic;
   7 using System.Net.WebSockets;
   8 using System.Reflection;
   9 using System.Text;
  10
  11 using NUnit.Framework;
  12
  13 using MonoTests.Helpers;
  14
  15 namespace MonoTests.System.Net.WebSockets
  16 {
  17         [TestFixture]
  18         public class ClientWebSocketTest
  19         {
  20                 const string EchoServerUrl = "ws://echo.websocket.org";
  21                 int Port = NetworkHelpers.FindFreePort ();
  22                 HttpListener listener;
  23                 ClientWebSocket socket;
  24                 MethodInfo headerSetMethod;
  25
  26                 [SetUp]
  27                 public void Setup ()
  28                 {
  29                         listener = new HttpListener ();
  30                         listener.Prefixes.Add ("http://localhost:" + Port + "/");
  31                         listener.Start ();
  32                         socket = new ClientWebSocket ();
  33                 }
  34
  35                 [TearDown]
  36                 public void Teardown ()
  37                 {
  38                         if (listener != null) {
  39                                 listener.Stop ();
  40                                 listener = null;
  41                         }
  42                         if (socket != null) {
  43                                 if (socket.State == WebSocketState.Open)
  44                                         socket.CloseAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (2000);
  45                                 socket.Dispose ();
  46                                 socket = null;
  47                         }
  48                 }
  49
  50                 [Test]
  51                 public void ServerHandshakeReturnCrapStatusCodeTest ()
  52                 {
  53                         // On purpose,
  54                         #pragma warning disable 4014
  55                         HandleHttpRequestAsync ((req, resp) => resp.StatusCode = 418);
  56                         #pragma warning restore 4014
  57                         try {
  58                                 Assert.IsTrue (socket.ConnectAsync (new Uri ("ws://localhost:" + Port), CancellationToken.None).Wait (5000));
  59                         } catch (AggregateException e) {
  60                                 AssertWebSocketException (e, WebSocketError.Success, typeof (WebException));
  61                                 return;
  62                         }
  63                         Assert.Fail ("Should have thrown");
  64                 }
  65
  66                 [Test]
  67                 public void ServerHandshakeReturnWrongUpgradeHeader ()
  68                 {
  69                         #pragma warning disable 4014
  70                         HandleHttpRequestAsync ((req, resp) => {
  71                                         resp.StatusCode = 101;
  72                                         resp.Headers["Upgrade"] = "gtfo";
  73                                 });
  74                         #pragma warning restore 4014
  75                         try {
  76                                 Assert.IsTrue (socket.ConnectAsync (new Uri ("ws://localhost:" + Port), CancellationToken.None).Wait (5000));
  77                         } catch (AggregateException e) {
  78                                 AssertWebSocketException (e, WebSocketError.Success);
  79                                 return;
  80                         }
  81                         Assert.Fail ("Should have thrown");
  82                 }
  83
  84                 [Test]
  85                 public void ServerHandshakeReturnWrongConnectionHeader ()
  86                 {
  87                         #pragma warning disable 4014
  88                         HandleHttpRequestAsync ((req, resp) => {
  89                                         resp.StatusCode = 101;
  90                                         resp.Headers["Upgrade"] = "websocket";
  91                                         // Mono http request doesn't like the forcing, test still valid since the default connection header value is empty
  92                                         //ForceSetHeader (resp.Headers, "Connection", "Foo");
  93                                 });
  94                         #pragma warning restore 4014
  95                         try {
  96                                 Assert.IsTrue (socket.ConnectAsync (new Uri ("ws://localhost:" + Port), CancellationToken.None).Wait (5000));
  97                         } catch (AggregateException e) {
  98                                 AssertWebSocketException (e, WebSocketError.Success);
  99                                 return;
 100                         }
 101                         Assert.Fail ("Should have thrown");
 102                 }
 103
 104                 [Test]
 105                 [Category ("AndroidNotWorking")] // The test hangs
 106                 public void EchoTest ()
 107                 {
 108                         const string Payload = "This is a websocket test";
 109
 110                         Assert.AreEqual (WebSocketState.None, socket.State);
 111                         socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait ();
 112                         Assert.AreEqual (WebSocketState.Open, socket.State);
 113
 114                         var sendBuffer = Encoding.ASCII.GetBytes (Payload);
 115                         Assert.IsTrue (socket.SendAsync (new ArraySegment<byte> (sendBuffer), WebSocketMessageType.Text, true, CancellationToken.None).Wait (5000));
 116
 117                         var receiveBuffer = new byte[Payload.Length];
 118                         var resp = socket.ReceiveAsync (new ArraySegment<byte> (receiveBuffer), CancellationToken.None).Result;
 119
 120                         Assert.AreEqual (Payload.Length, resp.Count);
 121                         Assert.IsTrue (resp.EndOfMessage);
 122                         Assert.AreEqual (WebSocketMessageType.Text, resp.MessageType);
 123                         Assert.AreEqual (Payload, Encoding.ASCII.GetString (receiveBuffer, 0, resp.Count));
 124
 125                         Assert.IsTrue (socket.CloseAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 126                         Assert.AreEqual (WebSocketState.Closed, socket.State);
 127                 }
 128
 129                 [Test]
 130                 public void CloseOutputAsyncTest ()
 131                 {
 132                         Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 133                         Assert.AreEqual (WebSocketState.Open, socket.State);
 134
 135                         Assert.IsTrue (socket.CloseOutputAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 136                         Assert.AreEqual (WebSocketState.CloseSent, socket.State);
 137
 138                         var resp = socket.ReceiveAsync (new ArraySegment<byte> (new byte[0]), CancellationToken.None).Result;
 139                         Assert.AreEqual (WebSocketState.Closed, socket.State);
 140                         Assert.AreEqual (WebSocketMessageType.Close, resp.MessageType);
 141                         Assert.AreEqual (WebSocketCloseStatus.NormalClosure, resp.CloseStatus);
 142                         Assert.AreEqual (string.Empty, resp.CloseStatusDescription);
 143                 }
 144
 145                 [Test]
 146                 public void CloseAsyncTest ()
 147                 {
 148                         Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 149                         Assert.AreEqual (WebSocketState.Open, socket.State);
 150
 151                         Assert.IsTrue (socket.CloseAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 152                         Assert.AreEqual (WebSocketState.Closed, socket.State);
 153                 }
 154
 155                 [Test, ExpectedException (typeof (InvalidOperationException))]
 156                 public void SendAsyncArgTest_NotConnected ()
 157                 {
 158                         socket.SendAsync (new ArraySegment<byte> (new byte[0]), WebSocketMessageType.Text, true, CancellationToken.None);
 159                 }
 160
 161                 [Test, ExpectedException (typeof (ArgumentNullException))]
 162                 public void SendAsyncArgTest_NoArray ()
 163                 {
 164                         Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 165                         socket.SendAsync (new ArraySegment<byte> (), WebSocketMessageType.Text, true, CancellationToken.None);
 166                 }
 167
 168                 [Test, ExpectedException (typeof (InvalidOperationException))]
 169                 public void ReceiveAsyncArgTest_NotConnected ()
 170                 {
 171                         socket.ReceiveAsync (new ArraySegment<byte> (new byte[0]), CancellationToken.None);
 172                 }
 173
 174                 [Test, ExpectedException (typeof (ArgumentNullException))]
 175                 public void ReceiveAsyncArgTest_NoArray ()
 176                 {
 177                         Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 178                         socket.ReceiveAsync (new ArraySegment<byte> (), CancellationToken.None);
 179                 }
 180
 181                 [Test]
 182                 public void ReceiveAsyncWrongState_Closed ()
 183                 {
 184                         try {
 185                                 Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 186                                 Assert.IsTrue (socket.CloseAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 187                                 Assert.IsTrue (socket.ReceiveAsync (new ArraySegment<byte> (new byte[0]), CancellationToken.None).Wait (5000));
 188                         } catch (AggregateException e) {
 189                                 AssertWebSocketException (e, WebSocketError.Success);
 190                                 return;
 191                         }
 192                         Assert.Fail ("Should have thrown");
 193                 }
 194
 195                 [Test]
 196                 public void SendAsyncWrongState_Closed ()
 197                 {
 198                         try {
 199                                 Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 200                                 Assert.IsTrue (socket.CloseAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 201                                 Assert.IsTrue (socket.SendAsync (new ArraySegment<byte> (new byte[0]), WebSocketMessageType.Text, true, CancellationToken.None).Wait (5000));
 202                         } catch (AggregateException e) {
 203                                 AssertWebSocketException (e, WebSocketError.Success);
 204                                 return;
 205                         }
 206                         Assert.Fail ("Should have thrown");
 207                 }
 208
 209                 [Test]
 210                 public void SendAsyncWrongState_CloseSent ()
 211                 {
 212                         try {
 213                                 Assert.IsTrue (socket.ConnectAsync (new Uri (EchoServerUrl), CancellationToken.None).Wait (5000));
 214                                 Assert.IsTrue (socket.CloseOutputAsync (WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait (5000));
 215                                 Assert.IsTrue (socket.SendAsync (new ArraySegment<byte> (new byte[0]), WebSocketMessageType.Text, true, CancellationToken.None).Wait (5000));
 216                         } catch (AggregateException e) {
 217                                 AssertWebSocketException (e, WebSocketError.Success);
 218                                 return;
 219                         }
 220                         Assert.Fail ("Should have thrown");
 221                 }
 222
 223                 [Test]
 224                 [Category ("NotWorking")]  // FIXME: test relies on unimplemented HttpListenerContext.AcceptWebSocketAsync (), reenable it when the method is implemented
 225                 public void SendAsyncEndOfMessageTest ()
 226                 {
 227                         var cancellationToken = new CancellationTokenSource (TimeSpan.FromSeconds (30)).Token;
 228                         SendAsyncEndOfMessageTest (false, WebSocketMessageType.Text, cancellationToken).Wait (5000);
 229                         SendAsyncEndOfMessageTest (true, WebSocketMessageType.Text, cancellationToken).Wait (5000);
 230                         SendAsyncEndOfMessageTest (false, WebSocketMessageType.Binary, cancellationToken).Wait (5000);
 231                         SendAsyncEndOfMessageTest (true, WebSocketMessageType.Binary, cancellationToken).Wait (5000);
 232                 }
 233
 234                 public async Task SendAsyncEndOfMessageTest (bool expectedEndOfMessage, WebSocketMessageType webSocketMessageType, CancellationToken cancellationToken)
 235                 {
 236                         using (var client = new ClientWebSocket ()) {
 237                                 // Configure the listener.
 238                                 var serverReceive = HandleHttpWebSocketRequestAsync<WebSocketReceiveResult> (async socket => await socket.ReceiveAsync (new ArraySegment<byte> (new byte[32]), cancellationToken), cancellationToken);
 239
 240                                 // Connect to the listener and make the request.
 241                                 await client.ConnectAsync (new Uri ("ws://localhost:" + Port + "/"), cancellationToken);
 242                                 await client.SendAsync (new ArraySegment<byte> (Encoding.UTF8.GetBytes ("test")), webSocketMessageType, expectedEndOfMessage, cancellationToken);
 243
 244                                 // Wait for the listener to handle the request and return its result.
 245                                 var result = await serverReceive;
 246
 247                                 // Cleanup and check results.
 248                                 await client.CloseAsync (WebSocketCloseStatus.NormalClosure, "Finished", cancellationToken);
 249                                 Assert.AreEqual (expectedEndOfMessage, result.EndOfMessage, "EndOfMessage should be " + expectedEndOfMessage);
 250                         }
 251                 }
 252
 253                 async Task<T> HandleHttpWebSocketRequestAsync<T> (Func<WebSocket, Task<T>> action, CancellationToken cancellationToken)
 254                 {
 255                         var ctx = await this.listener.GetContextAsync ();
 256                         var wsContext = await ctx.AcceptWebSocketAsync (null);
 257                         var result = await action (wsContext.WebSocket);
 258                         await wsContext.WebSocket.CloseOutputAsync (WebSocketCloseStatus.NormalClosure, "Finished", cancellationToken);
 259                         return result;
 260                 }
 261
 262                 async Task HandleHttpRequestAsync (Action<HttpListenerRequest, HttpListenerResponse> handler)
 263                 {
 264                         var ctx = await listener.GetContextAsync ();
 265                         handler (ctx.Request, ctx.Response);
 266                         ctx.Response.Close ();
 267                 }
 268
 269                 void AssertWebSocketException (AggregateException e, WebSocketError error, Type inner = null)
 270                 {
 271                         var wsEx = e.InnerException as WebSocketException;
 272                         Console.WriteLine (e.InnerException.ToString ());
 273                         Assert.IsNotNull (wsEx, "Not a websocketexception");
 274                         Assert.AreEqual (error, wsEx.WebSocketErrorCode);
 275                         if (inner != null) {
 276                                 Assert.IsNotNull (wsEx.InnerException);
 277                                 Assert.IsTrue (inner.IsInstanceOfType (wsEx.InnerException));
 278                         }
 279                 }
 280
 281                 void ForceSetHeader (WebHeaderCollection headers, string name, string value)
 282                 {
 283                         if (headerSetMethod == null)
 284                                 headerSetMethod = typeof (WebHeaderCollection).GetMethod ("AddValue", BindingFlags.NonPublic);
 285                         headerSetMethod.Invoke (headers, new[] { name, value });
 286                 }
 287         }
 288 }
 289
 290 #endif