From 4de768910b5f7a206206d1231a915c3bf123b27d Mon Sep 17 00:00:00 2001 From: jangko Date: Fri, 21 May 2021 15:56:13 +0700 Subject: [PATCH] text formatting: consistent indentation using 2 spaces for both `testtlswebsockets.nim` and `tests/testwebsockets.nim` --- tests/testtlswebsockets.nim | 1 - tests/testwebsockets.nim | 1455 ++++++++++++++++++----------------- 2 files changed, 730 insertions(+), 726 deletions(-) diff --git a/tests/testtlswebsockets.nim b/tests/testtlswebsockets.nim index 07f8d7c571..074a1c10fe 100644 --- a/tests/testtlswebsockets.nim +++ b/tests/testtlswebsockets.nim @@ -28,7 +28,6 @@ let secureKey = TLSPrivateKey.init(SecureKey) secureCert = TLSCertificate.init(SecureCert) - suite "Test websocket TLS handshake": teardown: await server.closeWait() diff --git a/tests/testwebsockets.nim b/tests/testwebsockets.nim index 359afd4687..c981a8db22 100644 --- a/tests/testwebsockets.nim +++ b/tests/testwebsockets.nim @@ -1,10 +1,10 @@ import std/[strutils, random], httputils import pkg/[asynctest, - chronos, - chronos/apps/http/httpserver, - chronicles, - stew/byteutils] + chronos, + chronos/apps/http/httpserver, + chronicles, + stew/byteutils] import ../ws/[ws, stream] @@ -14,186 +14,191 @@ var server: HttpServerRef let address = initTAddress("127.0.0.1:8888") proc rndStr*(size: int): string = - for _ in .. size: - add(result, char(rand(int('A') .. int('z')))) + for _ in .. size: + add(result, char(rand(int('A') .. int('z')))) proc waitForClose(ws: WebSocket) {.async.} = - try: - while ws.readystate != ReadyState.Closed: - discard await ws.recv() - except CatchableError: - debug "Closing websocket" + try: + while ws.readystate != ReadyState.Closed: + discard await ws.recv() + except CatchableError: + debug "Closing websocket" suite "Test handshake": - teardown: - await server.stop() - await server.closeWait() + teardown: + await server.stop() + await server.closeWait() - test "Test for incorrect protocol": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() + test "Test for incorrect protocol": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - expect WSProtoMismatchError: - discard await createServer(request, "proto") + let request = r.get() + check request.uri.path == "/ws" + expect WSProtoMismatchError: + discard await createServer(request, "proto") - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() - expect WSFailedUpgradeError: - discard await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["wrongproto"]) + expect WSFailedUpgradeError: + discard await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["wrongproto"]) - test "Test for incorrect version": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - expect WSVersionError: - discard await createServer(request, "proto") + test "Test for incorrect version": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + expect WSVersionError: + discard await createServer(request, "proto") - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() - expect WSFailedUpgradeError: - discard await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["wrongproto"], - version = 14) + expect WSFailedUpgradeError: + discard await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["wrongproto"], + version = 14) - test "Test for client headers": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() + test "Test for client headers": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - check request.headers.getString("Connection").toUpperAscii() == - "Upgrade".toUpperAscii() - check request.headers.getString("Upgrade").toUpperAscii() == - "websocket".toUpperAscii() - check request.headers.getString("Cache-Control").toUpperAscii() == - "no-cache".toUpperAscii() - check request.headers.getString("Sec-WebSocket-Version") == $WSDefaultVersion + let request = r.get() + check request.uri.path == "/ws" + check request.headers.getString("Connection").toUpperAscii() == + "Upgrade".toUpperAscii() + check request.headers.getString("Upgrade").toUpperAscii() == + "websocket".toUpperAscii() + check request.headers.getString("Cache-Control").toUpperAscii() == + "no-cache".toUpperAscii() + check request.headers.getString("Sec-WebSocket-Version") == $WSDefaultVersion - check request.headers.contains("Sec-WebSocket-Key") - discard await request.respond(Http200, "Connection established") + check request.headers.contains("Sec-WebSocket-Key") + discard await request.respond(Http200, "Connection established") - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() - expect WSFailedUpgradeError: - discard await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) + expect WSFailedUpgradeError: + discard await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) - test "Test for incorrect scheme": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() + test "Test for incorrect scheme": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" + let request = r.get() + check request.uri.path == "/ws" - expect WSProtoMismatchError: - var ws = await createServer(request, "proto") - check ws.readyState == ReadyState.Closed + expect WSProtoMismatchError: + var ws = await createServer(request, "proto") + check ws.readyState == ReadyState.Closed - return await request.respond(Http200, "Connection established") + return await request.respond(Http200, "Connection established") - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() - let uri = "wx://127.0.0.1:8888/ws" - expect WSWrongUriSchemeError: - discard await WebSocket.connect( - parseUri(uri), - protocols = @["proto"]) + let uri = "wx://127.0.0.1:8888/ws" + expect WSWrongUriSchemeError: + discard await WebSocket.connect( + parseUri(uri), + protocols = @["proto"]) - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false suite "Test transmission": - teardown: - await server.closeWait() + teardown: + await server.closeWait() - test "Send text message message with payload of length 65535": - let testString = rndStr(65535) - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - let servRes = await ws.recv() - check string.fromBytes(servRes) == testString + test "Send text message message with payload of length 65535": + let testString = rndStr(65535) + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + let servRes = await ws.recv() + check string.fromBytes(servRes) == testString - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - await wsClient.send(testString) - await wsClient.close() + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + await wsClient.send(testString) + await wsClient.close() - test "Server - test reading simple frame": + test "Server - test reading simple frame": + let testString = "Hello!" + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + let servRes = await ws.recv() + check string.fromBytes(servRes) == testString + await waitForClose(ws) + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + await wsClient.send(testString) + await wsClient.close() + + test "Client - test reading simple frame": + when defined(windows): + # TODO: fix this err on Windows + # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] + skip() + else: let testString = "Hello!" proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - let servRes = await ws.recv() - check string.fromBytes(servRes) == testString - await waitForClose(ws) + if r.isErr(): + return dumbResponse() - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - await wsClient.send(testString) - await wsClient.close() - - test "Client - test reading simple frame": - #[let testString = "Hello!" - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - await ws.send(testString) - await ws.close() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + await ws.send(testString) + await ws.close() let res = HttpServerRef.new(address, cb) server = res.get() @@ -207,341 +212,225 @@ suite "Test transmission": var clientRes = await wsClient.recv() check string.fromBytes(clientRes) == testString - await waitForClose(wsClient)]# + await waitForClose(wsClient) + + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false + +suite "Test ping-pong": + teardown: + await server.closeWait() + test "Send text Message fragmented into 2 fragments, one ping with payload in-between": + var ping, pong = false + let testString = "1234567890" + let msg = toBytes(testString) + let maxFrameSize = 5 + + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto", + onPing = proc() = + ping = true + ) + + let respData = await ws.recv() + check string.fromBytes(respData) == testString + await waitForClose(ws) + + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + frameSize = maxFrameSize, + onPong = proc() = + pong = true + ) + + let maskKey = genMaskKey(newRng()) + let encframe = encodeFrame(Frame( + fin: false, + rsv1: false, + rsv2: false, + rsv3: false, + opcode: Opcode.Text, + mask: true, + data: msg[0..4], + maskKey: maskKey)) + + await wsClient.stream.writer.write(encframe) + await wsClient.ping() + let encframe1 = encodeFrame(Frame( + fin: true, + rsv1: false, + rsv2: false, + rsv3: false, + opcode: Opcode.Cont, + mask: true, + data: msg[5..9], + maskKey: maskKey)) + + await wsClient.stream.writer.write(encframe1) + await wsClient.close() + check: + ping + pong + + test "Server - test ping-pong control messages": + when defined(windows): # TODO: fix this err on Windows # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] skip() - - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false - -suite "Test ping-pong": - teardown: - await server.closeWait() - test "Send text Message fragmented into 2 fragments, one ping with payload in-between": + else: var ping, pong = false - let testString = "1234567890" - let msg = toBytes(testString) - let maxFrameSize = 5 - - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto", - onPing = proc() = - ping = true - ) - - let respData = await ws.recv() - check string.fromBytes(respData) == testString - await waitForClose(ws) - - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - frameSize = maxFrameSize, - onPong = proc() = - pong = true - ) - - let maskKey = genMaskKey(newRng()) - let encframe = encodeFrame(Frame( - fin: false, - rsv1: false, - rsv2: false, - rsv3: false, - opcode: Opcode.Text, - mask: true, - data: msg[0..4], - maskKey: maskKey)) - - await wsClient.stream.writer.write(encframe) - await wsClient.ping() - let encframe1 = encodeFrame(Frame( - fin: true, - rsv1: false, - rsv2: false, - rsv3: false, - opcode: Opcode.Cont, - mask: true, - data: msg[5..9], - maskKey: maskKey)) - - await wsClient.stream.writer.write(encframe1) - await wsClient.close() - check: - ping - pong - - test "Server - test ping-pong control messages": - when defined(windows): - # TODO: fix this err on Windows - # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] - skip() - else: - var ping, pong = false - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto", - onPong = proc() = - pong = true - ) - - await ws.ping() - await ws.close() - - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - onPing = proc() = - ping = true - ) - - await waitForClose(wsClient) - check: - ping - pong - - test "Client - test ping-pong control messages": - var ping, pong = false - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto", - onPing = proc() = - ping = true - ) - await waitForClose(ws) - check: - ping - pong - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - onPong = proc() = - pong = true - ) - - await wsClient.ping() - await wsClient.close() - - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false - -suite "Test framing": - teardown: - await server.closeWait() - - test "should split message into frames": - let testString = "1234567890" - proc cb(r: RequestFence): Future[HttpResponseRef]{.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - - let ws = await createServer(request, "proto") - let frame1 = await ws.readFrame() - check not isNil(frame1) - var data1 = newSeq[byte](frame1.remainder().int) - let read1 = await ws.stream.reader.readOnce(addr data1[0], data1.len) - check read1 == 5 - - let frame2 = await ws.readFrame() - check not isNil(frame2) - var data2 = newSeq[byte](frame2.remainder().int) - let read2 = await ws.stream.reader.readOnce(addr data2[0], data2.len) - check read2 == 5 - - await waitForClose(ws) - - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - frameSize = 5) - - await wsClient.send(testString) - await wsClient.close() - - test "should fail to read past max message size": - when defined(windows): - # TODO: fix this err on Windows - # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] - skip() - else: - let testString = "1234567890" - proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - await ws.send(testString) - await ws.close() - - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - - expect WSMaxMessageSizeError: - discard await wsClient.recv(5) - await waitForClose(wsClient) - - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false - -suite "Test Closing": - teardown: - await server.closeWait() - - test "Server closing": - when defined(windows): - # TODO: fix this err on Windows - # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] - skip() - else: - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - await ws.close() - - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - - await waitForClose(wsClient) - check wsClient.readyState == ReadyState.Closed - - test "Server closing with status": - when defined(windows): - # TODO: fix this err on Windows - # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] - skip() - else: - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - - let request = r.get() - check request.uri.path == "/ws" - proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, - raises: [Defect].} = - try: - check status == Status.TooLarge - check reason == "Message too big!" - except Exception as exc: - raise newException(Defect, exc.msg) - - return (Status.Fulfilled, "") - - let ws = await createServer( - request, - "proto", - onClose = closeServer) - - await ws.close() - - let res = HttpServerRef.new(address, cb) - server = res.get() - server.start() - - proc clientClose(status: Status, reason: string): CloseResult {.gcsafe, - raises: [Defect].} = - try: - check status == Status.Fulfilled - return (Status.TooLarge, "Message too big!") - except Exception as exc: - raise newException(Defect, exc.msg) - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - onClose = clientClose) - - await waitForClose(wsClient) - check wsClient.readyState == ReadyState.Closed - - test "Client closing": proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = if r.isErr(): return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto", + onPong = proc() = + pong = true + ) + + await ws.ping() + await ws.close() + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + onPing = proc() = + ping = true + ) + + await waitForClose(wsClient) + check: + ping + pong + + test "Client - test ping-pong control messages": + var ping, pong = false + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto", + onPing = proc() = + ping = true + ) + await waitForClose(ws) + check: + ping + pong + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + onPong = proc() = + pong = true + ) + + await wsClient.ping() + await wsClient.close() + + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false + +suite "Test framing": + teardown: + await server.closeWait() + + test "should split message into frames": + let testString = "1234567890" + proc cb(r: RequestFence): Future[HttpResponseRef]{.async.} = + if r.isErr(): + return dumbResponse() + + let request = r.get() + check request.uri.path == "/ws" + + let ws = await createServer(request, "proto") + let frame1 = await ws.readFrame() + check not isNil(frame1) + var data1 = newSeq[byte](frame1.remainder().int) + let read1 = await ws.stream.reader.readOnce(addr data1[0], data1.len) + check read1 == 5 + + let frame2 = await ws.readFrame() + check not isNil(frame2) + var data2 = newSeq[byte](frame2.remainder().int) + let read2 = await ws.stream.reader.readOnce(addr data2[0], data2.len) + check read2 == 5 + + await waitForClose(ws) + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + frameSize = 5) + + await wsClient.send(testString) + await wsClient.close() + + test "should fail to read past max message size": + when defined(windows): + # TODO: fix this err on Windows + # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] + skip() + else: + let testString = "1234567890" + proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = + if r.isErr(): + return dumbResponse() + let request = r.get() check request.uri.path == "/ws" let ws = await createServer(request, "proto") - await waitForClose(ws) + await ws.send(testString) + await ws.close() let res = HttpServerRef.new(address, cb) server = res.get() @@ -552,41 +441,91 @@ suite "Test Closing": Port(8888), path = "/ws", protocols = @["proto"]) - await wsClient.close() - test "Client closing with status": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = - if r.isErr(): + expect WSMaxMessageSizeError: + discard await wsClient.recv(5) + await waitForClose(wsClient) + + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false + +suite "Test Closing": + teardown: + await server.closeWait() + + test "Server closing": + when defined(windows): + # TODO: fix this err on Windows + # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] + skip() + else: + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, - raises: [Defect].} = - try: - check status == Status.Fulfilled - return (Status.TooLarge, "Message too big!") - except Exception as exc: - raise newException(Defect, exc.msg) + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + await ws.close() - let ws = await createServer( - request, - "proto", - onClose = closeServer) - await waitForClose(ws) + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + + await waitForClose(wsClient) + check wsClient.readyState == ReadyState.Closed + + test "Server closing with status": + when defined(windows): + # TODO: fix this err on Windows + # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] + skip() + else: + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + + let request = r.get() + check request.uri.path == "/ws" + + proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, + raises: [Defect].} = + try: + check status == Status.TooLarge + check reason == "Message too big!" + except Exception as exc: + raise newException(Defect, exc.msg) + + return (Status.Fulfilled, "") + + let ws = await createServer( + request, + "proto", + onClose = closeServer) + + await ws.close() let res = HttpServerRef.new(address, cb) server = res.get() server.start() proc clientClose(status: Status, reason: string): CloseResult {.gcsafe, - raises: [Defect].} = - try: - check status == Status.TooLarge - check reason == "Message too big!" - return (Status.Fulfilled, "") - except Exception as exc: - raise newException(Defect, exc.msg) + raises: [Defect].} = + try: + check status == Status.Fulfilled + return (Status.TooLarge, "Message too big!") + except Exception as exc: + raise newException(Defect, exc.msg) let wsClient = await WebSocket.connect( "127.0.0.1", @@ -595,260 +534,326 @@ suite "Test Closing": protocols = @["proto"], onClose = clientClose) - await wsClient.close() + await waitForClose(wsClient) check wsClient.readyState == ReadyState.Closed - test "Server closing with valid close code 3999": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto") + test "Client closing": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() - await ws.close(code = Status.ReservedCode) + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + await waitForClose(ws) + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + await wsClient.close() + + test "Client closing with status": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = + if r.isErr(): + return dumbResponse() + + let request = r.get() + check request.uri.path == "/ws" + proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, + raises: [Defect].} = + try: + check status == Status.Fulfilled + return (Status.TooLarge, "Message too big!") + except Exception as exc: + raise newException(Defect, exc.msg) + + let ws = await createServer( + request, + "proto", + onClose = closeServer) + await waitForClose(ws) + + let res = HttpServerRef.new(address, cb) + server = res.get() + server.start() + + proc clientClose(status: Status, reason: string): CloseResult {.gcsafe, + raises: [Defect].} = + try: + check status == Status.TooLarge + check reason == "Message too big!" + return (Status.Fulfilled, "") + except Exception as exc: + raise newException(Defect, exc.msg) + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + onClose = clientClose) + + await wsClient.close() + check wsClient.readyState == ReadyState.Closed + + test "Server closing with valid close code 3999": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto") + + await ws.close(code = Status.ReservedCode) + + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() + + proc closeClient(status: Status, reason: string): CloseResult{.gcsafe, + raises: [Defect].} = + try: + check status == Status.ReservedCode + return (Status.ReservedCode, "Reserved Status") + except Exception as exc: + raise newException(Defect, exc.msg) + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + onClose = closeClient) + + await waitForClose(wsClient) + + test "Client closing with valid close code 3999": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + + proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, + raises: [Defect].} = + try: + check status == Status.ReservedCode + return (Status.ReservedCode, "Reserved Status") + except Exception as exc: + raise newException(Defect, exc.msg) + + let ws = await createServer( + request, + "proto", + onClose = closeServer) + + await waitForClose(ws) + return dumbResponse() + + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + await wsClient.close(code = Status.ReservedCode) + + test "Server closing with Payload of length 2": + when defined(windows): + # TODO: fix this err on Windows + # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] + skip() + else: + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + # Close with payload of length 2 + await ws.close(reason = "HH") let res = HttpServerRef.new( - address, cb) + address, cb) server = res.get() server.start() - proc closeClient(status: Status, reason: string): CloseResult{.gcsafe, - raises: [Defect].} = - try: - check status == Status.ReservedCode - return (Status.ReservedCode, "Reserved Status") - except Exception as exc: - raise newException(Defect, exc.msg) - let wsClient = await WebSocket.connect( "127.0.0.1", Port(8888), path = "/ws", - protocols = @["proto"], - onClose = closeClient) - + protocols = @["proto"]) await waitForClose(wsClient) - test "Client closing with valid close code 3999": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async, gcsafe.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" + test "Client closing with Payload of length 2": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + await waitForClose(ws) - proc closeServer(status: Status, reason: string): CloseResult{.gcsafe, - raises: [Defect].} = - try: - check status == Status.ReservedCode - return (Status.ReservedCode, "Reserved Status") - except Exception as exc: - raise newException(Defect, exc.msg) + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() - let ws = await createServer( - request, - "proto", - onClose = closeServer) + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + # Close with payload of length 2 + await wsClient.close(reason = "HH") - await waitForClose(ws) - return dumbResponse() + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - await wsClient.close(code = Status.ReservedCode) - - test "Server closing with Payload of length 2": - when defined(windows): - # TODO: fix this err on Windows - # Unhandled exception: Stream is already closed! [AsyncStreamIncorrectDefect] - skip() - else: - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - # Close with payload of length 2 - await ws.close(reason = "HH") - - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - await waitForClose(wsClient) - - test "Client closing with Payload of length 2": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - await waitForClose(ws) - - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - # Close with payload of length 2 - await wsClient.close(reason = "HH") - - - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false suite "Test Payload": - teardown: - await server.closeWait() + teardown: + await server.closeWait() - test "Test payload message length": - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto") + test "Test payload message length": + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto") - expect WSPayloadTooLarge: - discard await ws.recv() - await waitForClose(ws) + expect WSPayloadTooLarge: + discard await ws.recv() + await waitForClose(ws) - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() - let str = rndStr(126) - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) + let str = rndStr(126) + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) - await wsClient.send(toBytes(str), Opcode.Ping) - await wsClient.close() + await wsClient.send(toBytes(str), Opcode.Ping) + await wsClient.close() - test "Test single empty payload": - let emptyStr = "" - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - let servRes = await ws.recv() - check string.fromBytes(servRes) == emptyStr - await waitForClose(ws) + test "Test single empty payload": + let emptyStr = "" + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + let servRes = await ws.recv() + check string.fromBytes(servRes) == emptyStr + await waitForClose(ws) - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + await wsClient.send(emptyStr) + await wsClient.close() + + test "Test multiple empty payload": + let emptyStr = "" + proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer(request, "proto") + let servRes = await ws.recv() + check string.fromBytes(servRes) == emptyStr + await waitForClose(ws) + + let res = HttpServerRef.new( + address, cb) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"]) + + for i in 0..3: await wsClient.send(emptyStr) - await wsClient.close() + await wsClient.close() - test "Test multiple empty payload": - let emptyStr = "" - proc cb(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer(request, "proto") - let servRes = await ws.recv() - check string.fromBytes(servRes) == emptyStr - await waitForClose(ws) - - let res = HttpServerRef.new( - address, cb) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"]) - - for i in 0..3: - await wsClient.send(emptyStr) - await wsClient.close() - - test "Send ping with small text payload": - let testData = toBytes("Hello, world!") - var ping, pong = false - proc process(r: RequestFence): Future[HttpResponseRef] {.async.} = - if r.isErr(): - return dumbResponse() - let request = r.get() - check request.uri.path == "/ws" - let ws = await createServer( - request, - "proto", - onPing = proc() = - ping = true - ) - - await waitForClose(ws) - - let res = HttpServerRef.new( - address, process) - server = res.get() - server.start() - - let wsClient = await WebSocket.connect( - "127.0.0.1", - Port(8888), - path = "/ws", - protocols = @["proto"], - onPong = proc() = - pong = true + test "Send ping with small text payload": + let testData = toBytes("Hello, world!") + var ping, pong = false + proc process(r: RequestFence): Future[HttpResponseRef] {.async.} = + if r.isErr(): + return dumbResponse() + let request = r.get() + check request.uri.path == "/ws" + let ws = await createServer( + request, + "proto", + onPing = proc() = + ping = true ) - await wsClient.send(testData, Opcode.Ping) - await wsClient.close() - check: - ping - pong - test "AsyncStream leaks test": - check: - getTracker("async.stream.reader").isLeaked() == false - getTracker("async.stream.writer").isLeaked() == false - getTracker("stream.server").isLeaked() == false - getTracker("stream.transport").isLeaked() == false + await waitForClose(ws) + + let res = HttpServerRef.new( + address, process) + server = res.get() + server.start() + + let wsClient = await WebSocket.connect( + "127.0.0.1", + Port(8888), + path = "/ws", + protocols = @["proto"], + onPong = proc() = + pong = true + ) + + await wsClient.send(testData, Opcode.Ping) + await wsClient.close() + check: + ping + pong + + test "AsyncStream leaks test": + check: + getTracker("async.stream.reader").isLeaked() == false + getTracker("async.stream.writer").isLeaked() == false + getTracker("stream.server").isLeaked() == false + getTracker("stream.transport").isLeaked() == false