backend-test-tools 1.0.0

package/src/stubs/server-engine/PubSub.ts

@@ -0,0 +1,13 @@
+import {PubSub} from '@gwcdata/node-server-engine';
+import {stub} from 'sinon';
+import {PubSubStub} from './PubSub.types';
+
+/** Stub the PubSub service */
+export function stubPubSub(): PubSubStub {
+  const init = stub(PubSub, 'init').resolves();
+  const shutdown = stub(PubSub, 'shutdown').resolves();
+  const addPublisher = stub(PubSub, 'addPublisher').returns();
+  const addSubscriber = stub(PubSub, 'addSubscriber').returns();
+  const publish = stub(PubSub, 'publish').resolves();
+  return {init, shutdown, addPublisher, addSubscriber, publish};
+}

package/src/stubs/server-engine/PubSub.types.ts

@@ -0,0 +1,15 @@
+import {SinonStub} from 'sinon';
+
+/** Stubbed properties of the Pubsub entity */
+export interface PubSubStub {
+  /** Stub of the init method */
+  init: SinonStub;
+  /** Stub of the shutdown method */
+  shutdown: SinonStub;
+  /** Stub of the addPublisher method */
+  addPublisher: SinonStub;
+  /** Stub of the addSubscriber method */
+  addSubscriber: SinonStub;
+  /** Stub of the publish method */
+  publish: SinonStub;
+}

package/src/stubs/server-engine/PushNotification.ts

@@ -0,0 +1,11 @@
+import {PushNotification} from '@gwcdata/node-server-engine';
+import {stub} from 'sinon';
+import {PushNotificationStub} from './PushNotification.types';
+
+/** Stub the PushNotification service */
+export function stubPushNotification(): PushNotificationStub {
+  const init = stub(PushNotification, 'init').resolves();
+  const sendPush = stub(PushNotification, 'sendPush').resolves();
+
+  return {init, sendPush};
+}

package/src/stubs/server-engine/PushNotification.types.ts

@@ -0,0 +1,9 @@
+import {SinonStub} from 'sinon';
+
+/** Stubbed properties of the PushNotification entity */
+export interface PushNotificationStub {
+  /** Stub of the init method */
+  init: SinonStub;
+  /** Stub of the sendPush method */
+  sendPush: SinonStub;
+}

package/src/stubs/server-engine/index.ts

@@ -0,0 +1,4 @@
+export * from './Localizator';
+export * from './PubSub';
+export * from './sendPush';
+export * from './PushNotification';

package/src/stubs/server-engine/sendPush.ts

@@ -0,0 +1,7 @@
+import * as sendPush from '@gwcdata/node-server-engine/dist/utils/sendPush/sendPush';
+import {SinonStub, stub} from 'sinon';
+
+/** Stub the sendPush function */
+export function stubSendPush(): SinonStub {
+  return stub(sendPush, 'sendPush').resolves();
+}

package/src/utils/generateCerts/generateCerts.const.ts

@@ -0,0 +1,48 @@
+import {pki} from 'node-forge';
+
+export const baseAttributes: Array<pki.CertificateField> = [
+  {
+    name: 'countryName',
+    value: 'TW',
+  },
+  {
+    shortName: 'ST',
+    value: 'Taipei',
+  },
+  {
+    name: 'localityName',
+    value: 'Taipei',
+  },
+  {
+    name: 'organizationName',
+    value: 'Self',
+  },
+  {
+    shortName: 'OU',
+    value: 'Self',
+  },
+];
+
+export const caAttributes: Array<pki.CertificateField> = [
+  {
+    name: 'commonName',
+    value: 'root',
+  },
+  ...baseAttributes,
+];
+
+export const serverAttributes: Array<pki.CertificateField> = [
+  {
+    name: 'commonName',
+    value: 'server',
+  },
+  ...baseAttributes,
+];
+
+export const clientAttributes: Array<pki.CertificateField> = [
+  {
+    name: 'commonName',
+    value: 'client',
+  },
+  ...baseAttributes,
+];

package/src/utils/generateCerts/generateCerts.ts

@@ -0,0 +1,108 @@
+import fs from 'fs';
+import path from 'path';
+import {pki, md} from 'node-forge';
+import {caAttributes, clientAttributes, serverAttributes} from './generateCerts.const';
+import {generateCertsOptions, GeneratedCertificate} from './generateCerts.types';
+
+let serialNumber = 1;
+
+const dir = path.resolve('certs');
+
+/** Generate a certificate and a private key */
+export function generateCerts(
+  attributes: Array<pki.CertificateField>,
+  options: generateCertsOptions = {},
+): GeneratedCertificate {
+  const keys = pki.rsa.generateKeyPair(2048);
+  const cert = pki.createCertificate();
+  cert.publicKey = keys.publicKey;
+  const serial = `00${serialNumber.toString()}`;
+  cert.serialNumber = serial.substr(serial.length - 2);
+  serialNumber++;
+  cert.validity.notBefore = new Date();
+  cert.validity.notAfter = new Date();
+  cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+  cert.setSubject(attributes);
+  cert.setIssuer(options.issuer ?? attributes);
+  cert.setExtensions(getExtensions(options));
+  cert.sign(options.key ?? keys.privateKey, md.sha256.create());
+  return {
+    cert: pki.certificateToPem(cert),
+    privateKey: keys.privateKey,
+    privateKeyPem: pki.privateKeyToPem(keys.privateKey),
+  };
+}
+
+/**
+ * Generate a CA certificate as well as a client and a server private key and certificate
+ * These will be stored in the $ROOT/certs directoryA
+ */
+export function generatePkiEnvironment(): void {
+  const ca = generateCerts(caAttributes, {ca: true});
+  const client = generateCerts(clientAttributes, {key: ca.privateKey, issuer: caAttributes});
+  const server = generateCerts(serverAttributes, {key: ca.privateKey, issuer: caAttributes});
+
+  // Create directory if it does not exist
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+
+  fs.writeFileSync(path.resolve(dir, 'ca.crt'), ca.cert);
+  fs.writeFileSync(path.resolve(dir, 'ca.key'), ca.privateKeyPem);
+  fs.writeFileSync(path.resolve(dir, 'client.crt'), client.cert);
+  fs.writeFileSync(path.resolve(dir, 'client.key'), client.privateKeyPem);
+  fs.writeFileSync(path.resolve(dir, 'server.crt'), server.cert);
+  fs.writeFileSync(path.resolve(dir, 'server.key'), server.privateKeyPem);
+}
+
+/** Get the best fitting extensions for the certificate to generate */
+function getExtensions(options: generateCertsOptions = {}): Array<unknown> {
+  return [
+    {
+      name: 'basicConstraints',
+      cA: options.ca === true,
+    },
+    {
+      name: 'keyUsage',
+      keyCertSign: true,
+      digitalSignature: true,
+      nonRepudiation: true,
+      keyEncipherment: true,
+      dataEncipherment: true,
+    },
+    {
+      name: 'extKeyUsage',
+      serverAuth: true,
+      clientAuth: true,
+      codeSigning: true,
+      emailProtection: true,
+      timeStamping: true,
+    },
+    {
+      name: 'nsCertType',
+      client: true,
+      server: true,
+      email: true,
+      objsign: true,
+      sslCA: true,
+      emailCA: true,
+      objCA: true,
+    },
+    {
+      name: 'subjectAltName',
+      altNames: [
+        {
+          type: 2,
+          value: 'localhost',
+        },
+        {
+          type: 7,
+          ip: '127.0.0.1',
+        },
+      ],
+    },
+    {
+      name: 'subjectKeyIdentifier',
+    },
+  ];
+}

package/src/utils/generateCerts/generateCerts.types.ts

@@ -0,0 +1,21 @@
+import {pki} from 'node-forge';
+
+/** Options ot generate fake certificates */
+export interface generateCertsOptions {
+  /** Indicates that we should generate a CA certificate */
+  ca?: boolean;
+  /** Certificate issue information */
+  issuer?: Array<pki.CertificateField>;
+  /** Private key to use to sign the certificate */
+  key?: pki.PrivateKey;
+}
+
+/** Fake certificate generated */
+export interface GeneratedCertificate {
+  /** PEM certificate */
+  cert: string;
+  /** Private key to use with the certificate */
+  privateKey: pki.PrivateKey;
+  /** PEM encoding of the private key */
+  privateKeyPem: string;
+}

package/src/utils/generateCerts/index.ts

@@ -0,0 +1 @@
+export * from './generateCerts';

package/src/utils/getAdminApiBearer.ts

@@ -0,0 +1,17 @@
+import { faker } from '@faker-js/faker';
+import {generateAccessToken} from 'generators';
+
+/** Generate Admin api Bearer Token authorization header */
+export function getAdminApiBearer(email: string, payload = {}): string {
+  return `Bearer ${generateAccessToken(
+    email,
+    {
+      audience: process.env.ADMIN_API_ACCESS_TOKEN_AUDIENCE,
+      issuer: process.env.ADMIN_API_PUBLIC_URL,
+    },
+    {
+      per: [faker.lorem.word(), faker.lorem.word()],
+      ...payload,
+    },
+  )}`;
+}

package/src/utils/getBearer.ts

@@ -0,0 +1,11 @@
+import {SignOptions} from 'jsonwebtoken';
+import {generateAccessToken} from 'generators';
+
+/** Generate Bearer Token authorization header */
+export function getBearer(
+  userId: string,
+  options: SignOptions = {},
+  payload: string | object | Buffer = {},
+): string {
+  return `Bearer ${generateAccessToken(userId, options, payload)}`;
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './getBearer';
+export * from './tlsRequest';
+export * from './generateCerts';
+export * from './jwtRequest';
+export * from './staticRequest';
+export * from './getAdminApiBearer';

package/src/utils/jwtRequest.ts

@@ -0,0 +1,25 @@
+ 
+ 
+ 
+ 
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import supertest from 'supertest';
+import {getBearer} from './getBearer';
+
+/**
+ * Get a pre-configured generator for an express instance that uses JWT authentication
+ * @param {Object} app Express app
+ * @param {String} method Method in which the requests will be made
+ * @param {String} endpoint PAth of the endpoint where the requests are to be made
+ * @return {Function} - Supertest instance with JWT Authorization
+ */
+export function jwtRequest(app, method, endpoint) {
+  /**
+   * @param {Object} user User making the request
+   * @return {Object} Pre-configured supertest instance
+   */
+  return async function request(userId: string): supertest.Request {
+    return supertest(app)[method](endpoint).set('Authorization', getBearer(userId));
+  };
+}

package/src/utils/staticRequest.ts

@@ -0,0 +1,22 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import { Application } from 'express';
+import supertest from 'supertest';
+
+/**
+ * Get a pre-configured generator for an express instance that uses STATIC client key authentication
+ * @param app Express app
+ * @param method Method in which the requests will be made
+ * @param endpoint PAth of the endpoint where the requests are to be made
+ * @return - Supertest instance with STATIC Authorization
+ */
+export function staticRequest(
+  app: Application,
+  method: string,
+  endpoint: string
+) {
+  return async function request(): supertest.Request {
+    return supertest(app) [method](endpoint)
+      .set('Authorization', `Bearer ${process.env.STATIC_TOKEN as string}`);
+  };
+}

package/src/utils/tlsRequest.ts

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import {agent, Request} from 'supertest';
+import {tlsRequestOptions} from './tlsRequest.types';
+
+const customAgent = agent(`https://localhost:${process.env.PORT as string}`);
+
+let settings: tlsRequestOptions;
+
+/**
+ * Wrapper for supertest that adds TLS encryption
+ */
+export async function tlsRequest(options: tlsRequestOptions = {}): Promise<Request> {
+  if (!settings) loadDefaultSettings();
+  const ca = options.ca ? fs.readFileSync(options.ca, 'utf-8') : settings.ca;
+  const key = options.key ? fs.readFileSync(options.key, 'utf-8') : settings.key;
+  const cert = options.cert ? fs.readFileSync(options.cert, 'utf-8') : settings.cert;
+  if (!ca || !key || !cert) throw new Error('Missing some TLS configuration');
+  return customAgent.ca(ca).key(key).cert(cert);
+}
+
+/** Load TLS settings from env variables */
+function loadDefaultSettings(): void {
+  const {
+    TLS_REQUEST_KEY,
+    TLS_REQUEST_CERT,
+    TLS_REQUEST_CA,
+    TLS_SERVER_KEY,
+    TLS_SERVER_CERT,
+    TLS_CA,
+  } = process.env;
+
+  if (!(TLS_REQUEST_KEY || TLS_SERVER_KEY)) {
+    throw new Error('TLS Request: no TLS setting specified');
+  }
+
+  settings = {
+    key: fs.readFileSync((TLS_REQUEST_KEY ?? TLS_SERVER_KEY) as string, 'utf-8'),
+    cert: fs.readFileSync((TLS_REQUEST_CERT ?? TLS_SERVER_CERT) as string, 'utf-8'),
+    ca: fs.readFileSync((TLS_REQUEST_CA ?? TLS_CA) as string, 'utf-8'),
+  };
+}

package/src/utils/tlsRequest.types.ts

@@ -0,0 +1,9 @@
+/** Options for TLS requester */
+export interface tlsRequestOptions {
+  /** CA certificate used to validate the server */
+  ca?: string;
+  /** Key used to sign the requests */
+  key?: string;
+  /** Certificate to expose to the server */
+  cert?: string;
+}

package/test/env.ts

@@ -0,0 +1,10 @@
+/**
+ * Load a test environment
+ */
+process.env = {
+  SILENCE_REPORT: 'true',
+  PORT: '8080',
+  NODE_ENV: 'test',
+};
+
+export {};

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "baseUrl": "src",
+    "paths": {
+      "test": ["../test"],
+      "test/*": ["../test/*"]
+    },
+    "target": "ES6",
+    "lib": ["es2023"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": true,
+    "allowJs": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noFallthroughCasesInSwitch": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "emitDeclarationOnly": true
+  },
+  "include": ["src", "test"]
+}