@teamkeel/testing-runtime 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# `@teamkeel/testing-runtime`
+
+`@teamkeel/testng-runtime` is an internal package used by `@teamkeel/testing`. Do not install this package directly.

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@teamkeel/testing-runtime",
+  "version": "0.0.1",
+  "description": "Internal package used by the generated @teamkeel/testing package",
+  "exports": "./src/index.mjs",
+  "typings": "src/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "vitest run --reporter verbose",
+    "format": "npx prettier --write src/**/*"
+  },
+  "author": "Keel (www.keel.so)",
+  "license": "ASL (Apache 2.0)",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/lodash.ismatch": "^4.4.7",
+    "prettier": "2.7.1"
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0",
+    "kysely": "^0.23.4",
+    "lodash.ismatch": "^4.4.0",
+    "vitest": "^0.27.2"
+  }
+}

package/src/ActionExecutor.mjs

@@ -0,0 +1,85 @@
+import jwt from "jsonwebtoken";
+
+export class ActionExecutor {
+  constructor(props) {
+    this._identity = props.identity || null;
+    this._authToken = props.authToken || null;
+
+    // Return a proxy which will return a bound version of the
+    // _execute method for any unknown properties. This creates
+    // the actions API we want but in a dynamic way without needing
+    // codegen. We then generate the right type definitions for
+    // this class in the @teamkeel/testing package.
+    return new Proxy(this, {
+      get(target, prop) {
+        const v = Reflect.get(...arguments);
+        if (v !== undefined) {
+          return v;
+        }
+        return target._execute.bind(target, prop);
+      },
+    });
+  }
+  withIdentity(i) {
+    return new ActionExecutor({ identity: i });
+  }
+  withAuthToken(t) {
+    return new ActionExecutor({ authToken: t });
+  }
+  _execute(method, params) {
+    const headers = { "Content-Type": "application/json" };
+
+    // An Identity instance is provided make a JWT
+    if (this._identity !== null) {
+      headers["Authorization"] =
+        "Bearer " +
+        jwt.sign(
+          {},
+          // Not using a signing algorithm, therefore the private key is undefined
+          undefined,
+          {
+            algorithm: "none",
+            expiresIn: 60 * 60 * 24,
+            subject: this._identity.id,
+            issuer: "keel",
+          }
+        );
+    }
+
+    // If an auth token is provided that can be sent as-is
+    if (this._authToken !== null) {
+      headers["Authorization"] = "Bearer " + this._authToken;
+    }
+
+    // Use the HTTP JSON API as that returns more friendly errors than
+    // the JSON-RPC API.
+    return fetch(process.env.KEEL_TESTING_ACTIONS_API_URL + "/" + method, {
+      method: "POST",
+      body: JSON.stringify(params),
+      headers,
+    }).then((r) => {
+      if (r.status !== 200) {
+        // For non-200 first read the response as text
+        return r.text().then((t) => {
+          let d;
+          try {
+            d = JSON.parse(t);
+          } catch (e) {
+            // If JSON parsing fails then throw an error with the
+            // response text as the message
+            throw new Error(t);
+          }
+          // Otherwise throw the parsed JSON error response
+          // We override toString as otherwise you get expect errors like:
+          //   `expected to resolve but rejected with "[object Object]"`
+          Object.defineProperty(d, "toString", {
+            value: () => t,
+            enumerable: false,
+          });
+          throw d;
+        });
+      }
+      return r.json();
+    });
+  }
+}

package/src/JobExecutor.mjs

@@ -0,0 +1,87 @@
+import jwt from "jsonwebtoken";
+
+export class JobExecutor {
+  constructor(props) {
+    this._identity = props.identity || null;
+    this._authToken = props.authToken || null;
+
+    // Return a proxy which will return a bound version of the
+    // _execute method for any unknown properties. This creates
+    // the jobs API we want but in a dynamic way without needing
+    // codegen. We then generate the right type definitions for
+    // this class in the @teamkeel/testing package.
+    return new Proxy(this, {
+      get(target, prop) {
+        const v = Reflect.get(...arguments);
+        if (v !== undefined) {
+          return v;
+        }
+        return target._execute.bind(target, prop);
+      },
+    });
+  }
+  withIdentity(i) {
+    return new JobExecutor({ identity: i });
+  }
+  withAuthToken(t) {
+    return new JobExecutor({ authToken: t });
+  }
+  _execute(method, params) {
+    const headers = { "Content-Type": "application/json" };
+
+    // An Identity instance is provided make a JWT
+    if (this._identity !== null) {
+      headers["Authorization"] =
+        "Bearer " +
+        jwt.sign(
+          {},
+          // Not using a signing algorithm, therefore the private key is undefined
+          undefined,
+          {
+            algorithm: "none",
+            expiresIn: 60 * 60 * 24,
+            subject: this._identity.id,
+            issuer: "keel",
+          }
+        );
+    }
+
+    // If an auth token is provided that can be sent as-is
+    if (this._authToken !== null) {
+      headers["Authorization"] = "Bearer " + this._authToken;
+    }
+    return fetch(process.env.KEEL_TESTING_JOBS_URL + "/" + method, {
+      method: "POST",
+      body: JSON.stringify(params),
+      headers,
+    }).then((r) => {
+      if (r.status !== 200) {
+        // For non-200 first read the response as text
+        return r.text().then((t) => {
+          let d;
+          try {
+            d = JSON.parse(t);
+          } catch (e) {
+            if ("DEBUG" in process.env) {
+              console.log(e);
+            }
+            // If JSON parsing fails then throw an error with the
+            // response text as the message
+            throw new Error(t);
+          }
+          // Otherwise throw the parsed JSON error response
+          // We override toString as otherwise you get expect errors like:
+          //   `expected to resolve but rejected with "[object Object]"`
+          Object.defineProperty(d, "toString", {
+            value: () => t,
+            enumerable: false,
+          });
+
+          throw d;
+        });
+      }
+
+      return true;
+    });
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,21 @@
+// See https://vitest.dev/guide/extending-matchers.html for docs
+// on typing custom matchers
+
+interface ActionError {
+  code: string;
+  message: string;
+}
+
+interface CustomMatchers<R = unknown> {
+  toHaveAuthorizationError(): void;
+  toHaveError(err: Partial<ActionError>): void;
+}
+
+declare global {
+  namespace Vi {
+    interface Assertion extends CustomMatchers {}
+    interface AsymmetricMatchersContaining extends CustomMatchers {}
+  }
+}
+
+export {};

package/src/index.mjs

@@ -0,0 +1,5 @@
+export { sql } from "kysely";
+export { ActionExecutor } from "./ActionExecutor.mjs";
+export { JobExecutor } from "./JobExecutor.mjs";
+export { toHaveError } from "./toHaveError.mjs";
+export { toHaveAuthorizationError } from "./toHaveAuthorizationError.mjs";

package/src/index.test.ts

@@ -0,0 +1,37 @@
+import { expect, test } from "vitest";
+import "./index";
+
+test("toHaveAuthorizationError", async () => {
+  const p = Promise.reject({
+    code: "ERR_PERMISSION_DENIED",
+  });
+  await expect(p).toHaveAuthorizationError();
+});
+
+test("not.toHaveAuthorizationError", async () => {
+  const p = Promise.resolve({
+    id: "foo",
+  });
+  await expect(p).not.toHaveAuthorizationError();
+});
+
+test("toHaveError", async () => {
+  const p = Promise.reject({
+    code: "ERR_INVALID_INPUT",
+    message: "Invalid input",
+  });
+
+  await expect(p).toHaveError({
+    code: "ERR_INVALID_INPUT",
+  });
+});
+
+test("not.toHaveError", async () => {
+  const p = Promise.resolve({
+    id: "foo",
+  });
+
+  await expect(p).not.toHaveError({
+    code: "ERR_INVALID_INPUT",
+  });
+});

package/src/toHaveAuthorizationError.mjs

@@ -0,0 +1,21 @@
+export async function toHaveAuthorizationError(received) {
+  const { isNot } = this;
+  try {
+    const v = await received;
+    return {
+      pass: false,
+      message: () => "expected value to reject",
+      actual: v,
+    };
+  } catch (err) {
+    return {
+      pass: err.code === "ERR_PERMISSION_DENIED",
+      message: () =>
+        `expected there to be ${isNot ? "no " : ""}ERR_PERMISSION_DENIED error`,
+      actual: err,
+      expected: {
+        ...err,
+      },
+    };
+  }
+}

package/src/toHaveError.mjs

@@ -0,0 +1,23 @@
+import isMatch from "lodash.ismatch";
+
+export async function toHaveError(received, expected) {
+  const { isNot } = this;
+  try {
+    const v = await received;
+
+    return {
+      pass: false,
+      message: () => "expected value to reject",
+      actual: JSON.stringify(v),
+      expected: JSON.stringify(expected),
+    };
+  } catch (err) {
+    return {
+      pass: isMatch(err, expected),
+      message: () =>
+        `expected ${isNot ? "no " : ""} ${JSON.stringify(err)} error`,
+      actual: JSON.stringify(err),
+      expected: JSON.stringify(expected),
+    };
+  }
+}

package/src/vitest-setup.mjs

@@ -0,0 +1,12 @@
+// This file is loaded by Vitest because of the ../vitest.config.mjs file
+// which specifies it as a setupFile. When running tests with `keel test`
+// we tell Vitest to load that config file.
+
+import { expect } from "vitest";
+import { toHaveError } from "./toHaveError";
+import { toHaveAuthorizationError } from "./toHaveAuthorizationError";
+
+expect.extend({
+  toHaveError,
+  toHaveAuthorizationError,
+});

package/vitest.config.mjs

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["./src/vitest-setup"],
+  },
+});