fix: tests/helpers

Author: richard-ramos

libs/lsquic

@@ -0,0 +1,3 @@
+import pkg/chronos
+
+const zeroAddress* = initTAddress("0.0.0.0:0")

tests/helpers/addresses.nim

@@ -0,0 +1,25 @@
+import pkg/chronos
+
+type WaitGroup* = ref object of RootObj
+  ## A synchronization primitive that waits for a collection of 
+  ## asynchronous tasks to finish.
+  count: int
+  fut: Future[void]
+
+proc newWaitGroup*(count: int): WaitGroup =
+  doAssert(count >= 0, "WaitGroup count must be non negative number")
+  let fut = newFuture[void]("WaitGroup")
+  if count == 0:
+    fut.complete()
+  WaitGroup(count: count, fut: fut)
+
+proc wait*(wg: WaitGroup): Future[void] =
+  wg.fut
+
+proc done*(wg: WaitGroup) =
+  if wg.count == 0:
+    return
+
+  wg.count.dec
+  if wg.count == 0 and not wg.fut.finished:
+    wg.fut.complete()

tests/helpers/async.nim

@@ -0,0 +1,15 @@
+import sequtils
+import os
+
+const certificateStr =
+  staticRead(parentDir(currentSourcePath()) / "testCertificate.pem")
+const privateKeyStr = staticRead(parentDir(currentSourcePath()) / "testPrivateKey.pem")
+
+proc strToSeq(val: string): seq[byte] =
+  toSeq(val.toOpenArrayByte(0, val.high))
+
+proc testCertificate*(): seq[byte] =
+  strToSeq(certificateStr)
+
+proc testPrivateKey*(): seq[byte] =
+  strToSeq(privateKeyStr)

tests/helpers/certificate.nim

@@ -0,0 +1,28 @@
+import results
+import pkg/quic
+import ./certificate
+
+proc certificateCb(
+    serverName: string, derCertificates: seq[seq[byte]]
+): bool {.gcsafe.} =
+  return derCertificates.len > 0
+
+proc makeClient*(): QuicClient =
+  let customCertVerif: CertificateVerifier =
+    CustomCertificateVerifier.init(certificateCb)
+  let alpn = @["test"]
+  let tlsConfig = TLSConfig.init(
+    testCertificate(),
+    testPrivateKey(),
+    alpn,
+    certificateVerifier = Opt.some(customCertVerif),
+  )
+  return QuicClient.init(tlsConfig)
+
+proc makeServer*(): QuicServer =
+  let customCertVerif: CertificateVerifier =
+    CustomCertificateVerifier.init(certificateCb)
+  let alpn = @["test"]
+  let tlsConfig =
+    TLSConfig.init(testCertificate(), testPrivateKey(), alpn, Opt.some(customCertVerif))
+  return QuicServer.init(tlsConfig)

tests/helpers/clientserver.nim

@@ -0,0 +1,4 @@
+proc contains*(a: seq[byte], sub: seq[byte]): bool =
+  for i in 0 ..< a.len - sub.len:
+    if a[i ..< i + sub.len] == sub:
+      return true

tests/helpers/contains.nim

@@ -0,0 +1 @@
+--path:"../.."

tests/helpers/nim.cfg

@@ -0,0 +1,73 @@
+import std/[random, sets]
+import chronos
+import quic/transport/[quicconnection, quicclientserver, tlsbackend]
+import quic/helpers/[asyncloop, rand]
+import ./certificate
+import ./addresses
+
+proc networkLoop*(source, destination: QuicConnectionection) {.async.} =
+  proc transfer() {.async: (raises: [CancelledError]).} =
+    let datagram = await source.outgoing.get()
+    try:
+      destination.receive(datagram)
+    except CatchableError as e:
+      # this is used in tests so it's fine to raise defect
+      raise newException(Defect, e.msg)
+
+  await asyncLoop(transfer)
+
+proc simulateNetwork*(a, b: QuicConnectionection) {.async.} =
+  let loop1 = networkLoop(a, b)
+  let loop2 = networkLoop(b, a)
+  try:
+    await allFutures(loop1, loop2)
+  except CancelledError:
+    await allFutures(loop1.cancelAndWait(), loop2.cancelAndWait())
+
+proc lossyNetworkLoop*(source, destination: QuicConnectionection) {.async.} =
+  proc transfer() {.async: (raises: [CancelledError]).} =
+    let datagram = await source.outgoing.get()
+    if rand(1.0) < 0.2:
+      try:
+        destination.receive(datagram)
+      except CatchableError as e:
+        # this is used in tests so it's fine to raise defect
+        raise newException(Defect, e.msg)
+
+  await asyncLoop(transfer)
+
+proc simulateLossyNetwork*(a, b: QuicConnectionection) {.async.} =
+  let loop1 = lossyNetworkLoop(a, b)
+  let loop2 = lossyNetworkLoop(b, a)
+  try:
+    await allFutures(loop1, loop2)
+  except CancelledError:
+    await allFutures(loop1.cancelAndWait(), loop2.cancelAndWait())
+
+proc setupConnection*(): Future[tuple[client, server: QuicConnectionection]] {.async.} =
+  let rng = newRng()
+  let clientTLSBackend =
+    newClientTLSBackend(@[], @[], toHashSet(@["test"]), Opt.none(CertificateVerifier))
+  let client = newQuicClientConnection(clientTLSBackend, zeroAddress, zeroAddress, rng)
+
+  client.send() # Start Handshake
+  let datagram = await client.outgoing.get()
+  let serverTLSBackend = newServerTLSBackend(
+    testCertificate(),
+    testPrivateKey(),
+    toHashSet(@["test"]),
+    Opt.none(CertificateVerifier),
+  )
+  let server =
+    newQuicServerConnection(serverTLSBackend, zeroAddress, zeroAddress, datagram, rng)
+
+  result = (client, server)
+
+proc performHandshake*(): Future[tuple[client, server: QuicConnectionection]] {.async.} =
+  let (client, server) = await setupConnection()
+  let clientLoop = networkLoop(client, server)
+  let serverLoop = networkLoop(server, client)
+  await allFutures(client.handshake.wait(), server.handshake.wait())
+  await serverLoop.cancelAndWait()
+  await clientLoop.cancelAndWait()
+  result = (client, server)

tests/helpers/simulation.nim

@@ -0,0 +1,36 @@
+import pkg/chronos
+import pkg/unittest2
+import pkg/quic/transport/stream
+
+proc newData*(size: int, val: uint8 = uint8(0xEE)): seq[uint8] =
+  var data = newSeq[uint8](size)
+  for i in 0 ..< size:
+    data[i] = val
+  return data
+
+proc readStreamTillEOF*(
+    stream: Stream, maxBytes: int = int.high
+): Future[seq[uint8]] {.async.} =
+  ## Reads from stream until EOF is reached or the received data size meets/exceeds maxBytes
+
+  var receivedData: seq[uint8]
+  while true:
+    let chunk = await stream.read()
+    if chunk.len == 0:
+      break
+    receivedData.add(chunk)
+    if receivedData.len >= maxBytes:
+      break
+  return receivedData
+
+proc checkEqual*(a: seq[byte], b: seq[byte]) =
+  if a.len != b.len:
+    checkpoint("sequences do not have the same length: " & $a.len & " != " & $b.len)
+    fail()
+    return
+
+  for i in 0 ..< a.len:
+    if a[i] != b[i]:
+      checkpoint("sequences do not have same data")
+      fail()
+      return

tests/helpers/stream.nim

@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIB0jCCAXegAwIBAgIVAJUFhCQrlzzkFZbZkyXNRwCXSvYWMAwGCCqGSM49BAMC
+BQAwFDESMBAGA1UEAwwJbGlicDJwLmlvMCAXDTc1MDEwMTAwMDAwMFoYDzQwOTYw
+MTAxMDAwMDAwWjAUMRIwEAYDVQQDDAlsaWJwMnAuaW8wWTATBgcqhkjOPQIBBggq
+hkjOPQMBBwNCAAThQpOzDszrSDCf9wqR1+0WOt6BHVwv3Q3R+8quylRwLbR2D8ov
+PoXfWCzoACju9j2wBj4WHgb69Cpp9FiW7qx0o4GhMIGeMIGABgorBgEEAYOiWgEB
+BHIwbwQlCAISIQIz55rVQB21ks44HQ9G/0YJgvDB5v5/6Bl+MkQq5k3A4gRGMEQC
+IBLxYkAwI5H5GMzWPpjhOt3pJQ9gi7ICqCejEIFSuvf1AiA2kZZ+twfvyIYV7AAv
+InM3WOWZlgY4a7TDRm8C974pHwAwCQYDVR0TBAIwADAOBgNVHQ8BAf8EBAMCBaAw
+DAYIKoZIzj0EAwIFAANHADBEAiBV/KbtQ5SIAu373/8j/PzLnewCHUzXWTd3zjN9
+nzkGIgIgd1IJKDqnotzvCKw4WYrAmgTMkINJwlaQf278ranRaEY=
+-----END CERTIFICATE-----