How to use ShouldWork method of Microsoft.Playwright.Tests.WebSocketTests class

1/*
2 * MIT License
3 *
4 * Copyright (c) Microsoft Corporation.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25using System.Collections.Generic;
26using System.Threading.Tasks;
27using Microsoft.Playwright.NUnit;
28using NUnit.Framework;
29
30namespace Microsoft.Playwright.Tests
31{
32    ///<playwright-file>web-socket.spec.ts</playwright-file>
33    public class WebSocketTests : PageTestEx
34    {
35        [PlaywrightTest("web-socket.spec.ts", "should work")]
36        public async Task ShouldWork()
37        {
38            Server.SendOnWebSocketConnection("incoming");
39            string value = await Page.EvaluateAsync<string>(@"port => {
40                let cb;
41                const result = new Promise(f => cb = f);
42                const ws = new WebSocket('ws://localhost:' + port + '/ws');
43                ws.addEventListener('message', data => { ws.close(); cb(data.data); });
44                return result;
45            }", Server.Port);
46            Assert.AreEqual("incoming", value);
47        }
48
49        [PlaywrightTest("web-socket.spec.ts", "should emit close events")]
50        public async Task ShouldEmitCloseEvents()
51        {
52            var socketClosedTcs = new TaskCompletionSource<bool>();
53            var log = new List<string>();
54            IWebSocket webSocket = null;
55
56            Page.WebSocket += (_, e) =>
57            {
58                log.Add($"open<{e.Url}>");
59                webSocket = e;
60                webSocket.Close += (_, _) =>
61                {
62                    log.Add("close");
63                    socketClosedTcs.TrySetResult(true);
64                };
65            };
66
67            await Page.EvaluateAsync(@"port => {
68                const ws = new WebSocket('ws://localhost:' + port + '/ws');
69                ws.addEventListener('open', () => ws.close());
70            }", Server.Port);
71
72            await socketClosedTcs.Task;
73            Assert.AreEqual($"open<ws://localhost:{Server.Port}/ws>:close", string.Join(":", log));
74            Assert.True(webSocket.IsClosed);
75        }
76
77        [PlaywrightTest("web-socket.spec.ts", "should emit frame events")]
78        public async Task ShouldEmitFrameEvents()
79        {
80            Server.SendOnWebSocketConnection("incoming");
81            var socketClosedTcs = new TaskCompletionSource<bool>();
82            var log = new List<string>();
83
84            Page.WebSocket += (_, e) =>
85            {
86                log.Add($"open");
87
88                e.FrameSent += (_, e) => log.Add($"sent<{e.Text}>");
89                e.FrameReceived += (_, e) => log.Add($"received<{e.Text}>");
90
91                e.Close += (_, _) =>
92                {
93                    log.Add("close");
94                    socketClosedTcs.TrySetResult(true);
95                };
96            };
97
98            await Page.EvaluateAsync(@"port => {
99                const ws = new WebSocket('ws://127.0.0.1:' + port + '/ws');
100                ws.addEventListener('open', () => { ws.send('outgoing'); });
101                ws.addEventListener('message', e => { ws.close() });
102            }", Server.Port);
103
104            await socketClosedTcs.Task;
105            Assert.AreEqual("open", log[0]);
106            Assert.AreEqual("close", log[3]);
107            log.Sort();
108            Assert.AreEqual("close:open:received<incoming>:sent<outgoing>", string.Join(":", log));
109        }
110
111        [PlaywrightTest("web-socket.spec.ts", "should emit binary frame events")]
112        public async Task ShouldEmitBinaryFrameEvents()
113        {
114            var socketClosedTcs = new TaskCompletionSource<bool>();
115            var log = new List<IWebSocketFrame>();
116
117            Page.WebSocket += (_, e) =>
118            {
119                e.FrameSent += (_, e) => log.Add(e);
120                e.Close += (_, _) => socketClosedTcs.TrySetResult(true);
121            };
122
123            await Page.EvaluateAsync(@"port => {
124                const ws = new WebSocket('ws://localhost:' + port + '/ws');
125                ws.addEventListener('open', () => {
126                    const binary = new Uint8Array(5);
127                    for (let i = 0; i < 5; ++i)
128                        binary[i] = i;
129                    ws.send('text');
130                    ws.send(binary);
131                    ws.close();
132                });
133            }", Server.Port);
134
135
136            await socketClosedTcs.Task;
137            Assert.AreEqual("text", log[0].Text);
138
139            for (int i = 0; i < 5; i++)
140            {
141                Assert.AreEqual(i, log[1].Binary[i]);
142            }
143        }
144
145        [PlaywrightTest("web-socket.spec.ts", "should emit error")]
146        public async Task ShouldEmitError()
147        {
148            var socketErrorTcs = new TaskCompletionSource<string>();
149
150            Page.WebSocket += (_, e) =>
151            {
152                e.SocketError += (_, e) => socketErrorTcs.TrySetResult(e);
153            };
154
155            await Page.EvaluateAsync(@"port => {
156                new WebSocket('ws://localhost:' + port + '/bogus-ws');
157            }", Server.Port);
158
159
160            await socketErrorTcs.Task;
161
162            if (TestConstants.IsFirefox)
163            {
164                Assert.AreEqual("CLOSE_ABNORMAL", socketErrorTcs.Task.Result);
165            }
166            else
167            {
168                StringAssert.Contains(": 40", socketErrorTcs.Task.Result);
169            }
170        }
171
172        [PlaywrightTest("web-socket.spec.ts", "should not have stray error events")]
173        public async Task ShouldNotHaveStrayErrorEvents()
174        {
175            Server.SendOnWebSocketConnection("incoming");
176            var frameReceivedTcs = new TaskCompletionSource<bool>();
177            string socketError = null;
178            IWebSocket ws = null;
179
180            Page.WebSocket += (_, e) =>
181            {
182                ws = e;
183                e.SocketError += (_, e) => socketError = e;
184                e.FrameReceived += (_, _) => frameReceivedTcs.TrySetResult(true);
185            };
186
187            await TaskUtils.WhenAll(
188                frameReceivedTcs.Task,
189                Page.EvaluateAsync(@"port => {
190                    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
191                }", Server.Port));
192
193            await Page.EvaluateAsync("window.ws.close();");
194            Assert.Null(socketError);
195        }
196    }
197}
198

Source: WebSocketTests.cs

/*
 * MIT License
 *
 * Copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    ///<playwright-file>web-socket.spec.ts</playwright-file>
    public class WebSocketTests : PageTestEx
    {
        [PlaywrightTest("web-socket.spec.ts", "should work")]
        public async Task ShouldWork()
        {
            Server.SendOnWebSocketConnection("incoming");
            string value = await Page.EvaluateAsync<string>(@"port => {
                let cb;
                const result = new Promise(f => cb = f);
                const ws = new WebSocket('ws://localhost:' + port + '/ws');
                ws.addEventListener('message', data => { ws.close(); cb(data.data); });
                return result;
            }", Server.Port);
            Assert.AreEqual("incoming", value);
        }

        [PlaywrightTest("web-socket.spec.ts", "should emit close events")]
        public async Task ShouldEmitCloseEvents()
        {
            var socketClosedTcs = new TaskCompletionSource<bool>();
            var log = new List<string>();
            IWebSocket webSocket = null;

            Page.WebSocket += (_, e) =>
            {
                log.Add($"open<{e.Url}>");
                webSocket = e;
                webSocket.Close += (_, _) =>
                {
                    log.Add("close");
                    socketClosedTcs.TrySetResult(true);
                };
            };

            await Page.EvaluateAsync(@"port => {
                const ws = new WebSocket('ws://localhost:' + port + '/ws');
                ws.addEventListener('open', () => ws.close());
            }", Server.Port);

            await socketClosedTcs.Task;
            Assert.AreEqual($"open<ws://localhost:{Server.Port}/ws>:close", string.Join(":", log));
            Assert.True(webSocket.IsClosed);
        }

        [PlaywrightTest("web-socket.spec.ts", "should emit frame events")]
        public async Task ShouldEmitFrameEvents()
        {
            Server.SendOnWebSocketConnection("incoming");
            var socketClosedTcs = new TaskCompletionSource<bool>();
            var log = new List<string>();

            Page.WebSocket += (_, e) =>
            {
                log.Add($"open");

                e.FrameSent += (_, e) => log.Add($"sent<{e.Text}>");
                e.FrameReceived += (_, e) => log.Add($"received<{e.Text}>");

                e.Close += (_, _) =>
                {
                    log.Add("close");
                    socketClosedTcs.TrySetResult(true);
                };
            };

            await Page.EvaluateAsync(@"port => {
                const ws = new WebSocket('ws://127.0.0.1:' + port + '/ws');
                ws.addEventListener('open', () => { ws.send('outgoing'); });
                ws.addEventListener('message', e => { ws.close() });
            }", Server.Port);

            await socketClosedTcs.Task;
            Assert.AreEqual("open", log[0]);
            Assert.AreEqual("close", log[3]);
            log.Sort();
            Assert.AreEqual("close:open:received<incoming>:sent<outgoing>", string.Join(":", log));
        }

        [PlaywrightTest("web-socket.spec.ts", "should emit binary frame events")]
        public async Task ShouldEmitBinaryFrameEvents()
        {
            var socketClosedTcs = new TaskCompletionSource<bool>();
            var log = new List<IWebSocketFrame>();

            Page.WebSocket += (_, e) =>
            {
                e.FrameSent += (_, e) => log.Add(e);
                e.Close += (_, _) => socketClosedTcs.TrySetResult(true);
            };

            await Page.EvaluateAsync(@"port => {
                const ws = new WebSocket('ws://localhost:' + port + '/ws');
                ws.addEventListener('open', () => {
                    const binary = new Uint8Array(5);
                    for (let i = 0; i < 5; ++i)
                        binary[i] = i;
                    ws.send('text');
                    ws.send(binary);
                    ws.close();
                });
            }", Server.Port);


            await socketClosedTcs.Task;
            Assert.AreEqual("text", log[0].Text);

            for (int i = 0; i < 5; i++)
            {
                Assert.AreEqual(i, log[1].Binary[i]);
            }
        }

        [PlaywrightTest("web-socket.spec.ts", "should emit error")]
        public async Task ShouldEmitError()
        {
            var socketErrorTcs = new TaskCompletionSource<string>();

            Page.WebSocket += (_, e) =>
            {
                e.SocketError += (_, e) => socketErrorTcs.TrySetResult(e);
            };

            await Page.EvaluateAsync(@"port => {
                new WebSocket('ws://localhost:' + port + '/bogus-ws');
            }", Server.Port);


            await socketErrorTcs.Task;

            if (TestConstants.IsFirefox)
            {
                Assert.AreEqual("CLOSE_ABNORMAL", socketErrorTcs.Task.Result);
            }
            else
            {
                StringAssert.Contains(": 40", socketErrorTcs.Task.Result);
            }
        }

        [PlaywrightTest("web-socket.spec.ts", "should not have stray error events")]
        public async Task ShouldNotHaveStrayErrorEvents()
        {
            Server.SendOnWebSocketConnection("incoming");
            var frameReceivedTcs = new TaskCompletionSource<bool>();
            string socketError = null;
            IWebSocket ws = null;

            Page.WebSocket += (_, e) =>
            {
                ws = e;
                e.SocketError += (_, e) => socketError = e;
                e.FrameReceived += (_, _) => frameReceivedTcs.TrySetResult(true);
            };

            await TaskUtils.WhenAll(
                frameReceivedTcs.Task,
                Page.EvaluateAsync(@"port => {
                    window.ws = new WebSocket('ws://localhost:' + port + '/ws');
                }", Server.Port));

            await Page.EvaluateAsync("window.ws.close();");
            Assert.Null(socketError);
        }
    }
}