feat: add basic test and testing core

Author: egor-romanov

.gitignore

@@ -105,4 +105,8 @@ dist
 .tern-port
 
 # Generated docs
-docs/
+docs/
+
+# Test reports
+allure-results
+allure-report

.mocharc.yml

@@ -0,0 +1,21 @@
+async-only: true
+bail: false
+check-leaks: true
+color: true
+delay: false
+diff: true
+exit: false # could be expressed as "no-exit: true"
+extension:
+  - ts
+full-trace: false
+recursive: true
+require:
+  - 'ts-node/register'
+  - source-map-support/register
+retries: 0
+sort: false
+spec: test/spec/**/*.spec.ts
+timeout: 60000
+reporter: mocha-multi-reporters
+reporter-options: configFile=config.json
+globals: 'allure'

config.json

@@ -0,0 +1,3 @@
+{
+  "reporterEnabled": "spec,mocha-allure2-reporter"
+}

package.json

@@ -14,7 +14,10 @@
     "build:module": "tsc -p tsconfig.module.json",
     "docs": "typedoc src/index.ts src/types.ts --excludePrivate --excludeProtected",
     "docs:json": "typedoc --json docs/spec.json --excludeExternals src/index.ts src/types.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "mocha",
+    "allure:generate": "node_modules/allure-commandline/bin/allure generate",
+    "allure:serve": "node_modules/allure-commandline/bin/allure serve",
+    "test:report": "npm run allure:generate && npm run allure:serve"
   },
   "repository": {
     "type": "git",
@@ -38,12 +41,31 @@
     "cross-fetch": "^3.1.5"
   },
   "devDependencies": {
+    "@types/chai": "^4.3.0",
+    "@types/jsonwebtoken": "^8.5.8",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.23",
+    "allure-commandline": "^2.17.2",
+    "chai": "^4.3.6",
+    "genversion": "^3.0.2",
+    "jsonwebtoken": "^8.5.1",
+    "mocha": "^8.4.0",
+    "mocha-allure2-reporter": "^0.0.3",
+    "mocha-multi-reporters": "^1.5.1",
+    "nanoid": "^3.3.1",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.6.0",
     "rimraf": "^3.0.2",
     "semantic-release": "^19.0.2",
     "semantic-release-plugin-update-version-in-files": "^1.1.0",
+<<<<<<< HEAD
     "typedoc": "^0.22.16",
+=======
+    "testcontainers": "^8.5.1",
+    "ts-node": "^10.7.0",
+    "ts-test-decorators": "^0.0.6",
+    "typedoc": "^0.22.13",
+>>>>>>> b3a0615 (feat: add basic test and testing core)
     "typescript": "^4.6.2"
   },
   "publishConfig": {

test/functions/hello.ts

@@ -0,0 +1,3 @@
+import { serve } from 'https://deno.land/std/http/server.ts'
+
+serve(() => new Response('Hello World'))

test/relay/container.ts

@@ -0,0 +1,125 @@
+import * as fs from 'fs'
+import { nanoid } from 'nanoid'
+import { GenericContainer, Network, StartedTestContainer, Wait } from 'testcontainers'
+import { ExecResult } from 'testcontainers/dist/docker/types'
+import { ContentType } from 'allure2-js-commons'
+import { attach, log } from '../utils/allure'
+
+/**
+ * A Relay contains a running relay container that has a unique ID and two promises:
+ * one for the `deno cache` and one for the `deno run` the required function
+ */
+export class Relay {
+  container: StartedTestContainer
+  id: string
+  execCache: Promise<ExecResult>
+  execRun: Promise<ExecResult>
+  constructor(
+    container: StartedTestContainer,
+    id: string,
+    execCache: Promise<ExecResult>,
+    execRun: Promise<ExecResult>
+  ) {
+    this.container = container
+    this.id = id
+    this.execCache = execCache
+    this.execRun = execRun
+  }
+}
+
+/**
+ * It starts a docker container with a deno relay, and waits for it to be ready
+ * @param {string} slug - the name of the function to deploy
+ * @param {string} jwtSecret - the JWT secret to access function
+ * @param {string} [denoOrigin=http://localhost:8000] - the origin of the deno server
+ * @param {Map<string, string>} env - list of environment variables for deno relay
+ * @returns {Promise<Relay>} A Relay object.
+ */
+export async function runRelay(
+  slug: string,
+  jwtSecret: string,
+  denoOrigin: string = 'http://localhost:8000',
+  env?: Map<string, string>
+): Promise<Relay> {
+  // read function to deploy
+  log('read function body')
+  const functionBytes = fs.readFileSync('test/functions/' + slug + '.ts', 'utf8')
+  attach('function body', functionBytes, ContentType.TEXT)
+
+  // random id for parallel execution
+  const id = nanoid(5)
+
+  //create network
+  log('add network')
+  const network = await new Network({ name: 'supabase_network_' + id }).start()
+
+  // create relay container
+  log(`create relay ${slug + '-' + id}`)
+  const relay = await new GenericContainer('supabase/deno-relay')
+    .withName(slug + '-' + id)
+    .withCmd([
+      'sh',
+      '-c',
+      `cat <<'EOF' > /home/deno/${slug}.ts && deno run --allow-all index.ts
+` +
+        functionBytes +
+        `
+EOF
+`,
+    ])
+    .withNetworkMode(network.getName())
+    .withExposedPorts(8081)
+    .withWaitStrategy(Wait.forLogMessage('Listening on http://0.0.0.0:8081'))
+    .withStartupTimeout(15000)
+    .withReuse()
+
+  // add envs
+  env = parseEnv(env, jwtSecret, denoOrigin)
+  env && env.forEach((value, key) => relay.withEnv(key, value))
+
+  // start relay and function
+  log(`start relay ${slug + '-' + id}`)
+  const startedRelay = await relay.start()
+  const execCache = startedRelay.exec(['deno', 'cache', `/home/deno/${slug}.ts`])
+  const execRun = startedRelay.exec(['deno', 'run', '--allow-all', `/home/deno/${slug}.ts`])
+
+  // wait till function is running
+  log(`check function is healthy: ${slug + '-' + id}`)
+  for (let ctr = 0; ctr < 30; ctr++) {
+    const healthCheck = await startedRelay.exec(['nc', '-z', 'localhost', '8000'])
+    if (healthCheck.exitCode == 0) {
+      log(`function started to serve: ${slug + '-' + id}`)
+      return { container: startedRelay, id, execCache, execRun }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500))
+  }
+
+  // if function hasn't started, stop container and throw
+  log(`function failed to start: ${slug + '-' + id}`)
+  startedRelay.stop()
+  throw new Error("function haven'start correctly")
+}
+
+/**
+ * If the JWT_SECRET and DENO_ORIGIN environment is not set, set it
+ * @param env - The environment variables.
+ * @param {string} jwtSecret - The JWT secret.
+ * @param {string} denoOrigin - The origin of the Deno server.
+ * @returns {Map<string, string>} - `env` variables map.
+ */
+function parseEnv(
+  env: Map<string, string> | undefined | null,
+  jwtSecret: string,
+  denoOrigin: string
+): Map<string, string> {
+  if (env) {
+    !env.has('JWT_SECRET') && jwtSecret && env.set('JWT_SECRET', jwtSecret)
+    !env.has('DENO_ORIGIN') && denoOrigin && env.set('DENO_ORIGIN', denoOrigin)
+  } else {
+    env = new Map([
+      ['JWT_SECRET', jwtSecret],
+      ['DENO_ORIGIN', denoOrigin],
+    ])
+  }
+  return env
+}

test/spec/hello.spec.ts

@@ -0,0 +1,37 @@
+import 'mocha'
+import { assert } from 'chai'
+import { nanoid } from 'nanoid'
+import { sign } from 'jsonwebtoken'
+
+import { FunctionsClient } from '../../src/index'
+
+import { Relay, runRelay } from '../relay/container'
+import { log } from '../utils/allure'
+
+describe('HelloTest', () => {
+  let relay: Relay
+  let fclient: FunctionsClient
+  const jwtSecret = nanoid(10)
+  let apiKey = sign({ name: 'anon' }, jwtSecret)
+
+  before(async () => {
+    relay = await runRelay('hello', jwtSecret)
+    fclient = new FunctionsClient(`http://localhost:${relay.container.getMappedPort(8081)}`, {
+      Authorization: `Bearer ${apiKey}`,
+    })
+  })
+
+  after(async () => {
+    relay && relay.container && (await relay.container.stop())
+  })
+
+  it('set up relay with hello function and invoke it', async () => {
+    log('invoke hello')
+    const { data, error } = await fclient.invoke('hello', { responseType: 'text' })
+
+    log('assert no error')
+    assert.isNull(error)
+    log(`assert ${data} is equal to 'Hello World'`)
+    assert.equal(data, 'Hello World')
+  })
+})

test/utils/allure.ts

@@ -0,0 +1,89 @@
+import { Allure } from 'allure-js-commons'
+import { ContentType } from 'allure2-js-commons'
+
+type TestDecorator = (
+  target: object,
+  property: string,
+  descriptor: PropertyDescriptor
+) => PropertyDescriptor
+
+function getAllure(): Allure {
+  // @ts-ignore
+  const allure: Allure = global.allure
+  if (!allure) {
+    throw new Error('Unable to find Allure implementation')
+  }
+  return allure
+}
+
+export function step<T>(nameFn: string | ((arg: T) => string)): TestDecorator {
+  return (target: object, propertyKey: string, descriptor: PropertyDescriptor) => {
+    const original: object = descriptor.value
+    let callable: (args: T) => void = () => {
+      /* */
+    }
+
+    if (typeof original === 'function') {
+      descriptor.value = function (...args: [T]) {
+        try {
+          const value: string = typeof nameFn === 'function' ? nameFn.apply(this, args) : nameFn
+          callable = () => getAllure().step(value, () => original.apply(this, args))
+          // tslint:disable-next-line:no-console
+          console.info(`Step: ${value || nameFn}`)
+        } catch (e) {
+          // tslint:disable-next-line:no-console
+          console.error(`[ERROR] Failed to apply decorator: ${e}`)
+        }
+        return callable.apply(this, args)
+      }
+    }
+    return descriptor
+  }
+}
+
+export function attachment<T>(name: string, type: ContentType) {
+  return (
+    _target: object,
+    _propertyKey: string,
+    descriptor: PropertyDescriptor
+  ): PropertyDescriptor => {
+    const original: object = descriptor.value
+    let callable: (args: T) => void = () => {
+      /* */
+    }
+
+    if (typeof original === 'function') {
+      descriptor.value = async function (...args: [T]) {
+        try {
+          const content: Buffer | string = await original.apply(this, args)
+          callable = () =>
+            getAllure().step(name, () => {
+              getAllure().attachment(type.toString(), content, type)
+            })
+        } catch (e) {
+          // tslint:disable-next-line:no-console
+          console.error(`[ERROR] Failed to apply decorator: ${e}`)
+        }
+        return callable.apply(this, args)
+      }
+    }
+    return descriptor
+  }
+}
+
+export function attach(name: string, content: string | Buffer, type: ContentType): void {
+  getAllure().step(name, () => {
+    getAllure().attachment(type.toString(), content, type)
+  })
+}
+
+export function log(name: string, description?: string): void {
+  // console.info(description ? `${name}: ${description}` : name);
+  getAllure().step(name, () => {
+    if (description) {
+      getAllure().step(description, () => {
+        /* */
+      })
+    }
+  })
+}

test/utils/timeoutPromise.ts

@@ -0,0 +1,11 @@
+export default async function timeoutRequest<T>(request: Promise<T>, timeout: number): Promise<T> {
+  let timer: NodeJS.Timeout
+
+  request.finally(() => clearTimeout(timer))
+
+  const timeoutPromise = new Promise<T>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Timeout (${timeout}) for task exceeded`)), timeout)
+  })
+
+  return Promise.race<T>([request, timeoutPromise])
+}

tsconfig.json

@@ -5,6 +5,8 @@
     "declaration": true,
     "declarationMap": true,
     "module": "CommonJS",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
     "outDir": "dist/main",
     "rootDir": "src",
     "sourceMap": true,
@@ -18,5 +20,9 @@
     "forceConsistentCasingInFileNames": true,
     "stripInternal": true,
     "allowSyntheticDefaultImports": true
-  }
+  },
+  "typeRoots": [
+    "./node_modules/allure2-js-commons/dist/declarations/**/",
+    "./src/types"
+  ]
 }