backend-test-tools 1.0.0

package/src/factory/factory.ts

@@ -0,0 +1,51 @@
+import {randomUUID} from 'crypto';
+import {
+  FactoryModel,
+  FactoryBuildOptions,
+  FactoryModelOverride,
+  FactoryReturnType,
+  ModelsMap,
+} from './factory.types';
+import {connectionFactoryWorker, organizationFactoryWorker, userFactoryWorker} from './workers';
+
+const modelsMap: ModelsMap = {
+  connection: connectionFactoryWorker,
+  organization: organizationFactoryWorker,
+  user: userFactoryWorker,
+};
+
+export const factory = {
+  /**
+   * Build an object according to a defined model
+   */
+  build: function <T extends FactoryModel>(
+    name: T,
+    attributes: FactoryModelOverride<T> = {},
+    buildOptions: FactoryBuildOptions<T> = {},
+  ): FactoryReturnType<T> {
+    if (!Object.keys(modelsMap).includes(name)) throw new Error(`Factory: unknown model "${name}"`);
+    const worker = modelsMap[name];
+    const instance = worker(buildOptions);
+    return {
+      id: randomUUID(),
+      ...instance,
+      ...attributes,
+    };
+  },
+
+  /**
+   * Build multiple objects according to a defined model
+   */
+  buildMany: function <T extends FactoryModel>(
+    name: T,
+    count: number,
+    attributes: FactoryModelOverride<T> = {},
+    buildOptions: FactoryBuildOptions<T> = {},
+  ): Array<FactoryReturnType<T>> {
+    const instances: Array<FactoryReturnType<T>> = [];
+    for (let i = 0; i < count; i++) {
+      instances.push(this.build(name, attributes, buildOptions));
+    }
+    return instances;
+  },
+};

package/src/factory/factory.types.ts

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  ConnectionModel,
+  ConnectionBuildOptions,
+  OrganizationModel,
+  UserModel,
+  UserBuildOptions,
+} from './workers';
+
+type FactoryTyping = {
+  /** Mapping for the connection model */
+  connection: {
+    /** Options for the connection model */
+    options: ConnectionBuildOptions;
+    /** Return type for the connection model */
+    return: ConnectionModel;
+  };
+  /** Mapping for the organization model */
+  organization: {
+    /** Options for the organization model */
+    options: any;
+    /** Return type for the organization model */
+    return: OrganizationModel;
+  };
+  /** Mapping for the user model */
+  user: {
+    /** Options for the user model */
+    options: UserBuildOptions;
+    /** Return type for the user model */
+    return: UserModel;
+  };
+};
+
+export type FactoryModel = keyof FactoryTyping;
+
+export type FactoryModelOverride<T extends FactoryModel> = Partial<FactoryTyping[T]['return']> & {
+  /** Id of the model */
+  id?: string;
+};
+
+export type FactoryBuildOptions<T extends FactoryModel> = FactoryTyping[T]['options'];
+
+export type FactoryReturnType<T extends FactoryModel> = FactoryTyping[T]['return'] & {
+  /** Id of the model */
+  id: string;
+};
+
+export type ModelsMap = {
+  [T in FactoryModel]: (buildOptions: FactoryTyping[T]['options']) => FactoryTyping[T]['return'];
+};

package/src/factory/index.ts

@@ -0,0 +1,2 @@
+export * from './workers';
+export * from './factory';

package/src/factory/workers/connection.ts

@@ -0,0 +1,22 @@
+import {randomUUID} from 'crypto';
+import { faker } from '@faker-js/faker';
+import {ConnectionBuildOptions, ConnectionModel} from './connection.types';
+
+/** Create a random connection */
+export function connectionFactoryWorker(
+  buildOptions: ConnectionBuildOptions = {},
+): ConnectionModel {
+  const accepted = buildOptions.accepted ?? true;
+  const blocked = buildOptions.blocked ?? false;
+  return {
+    ownerId: randomUUID(),
+    otherUserId: randomUUID(),
+    accepted,
+    acceptedAt: accepted ? faker.date.recent() : undefined,
+    blocked,
+    blockedAt: blocked ? faker.date.recent() : undefined,
+    initiator: true,
+    message: faker.lorem.sentence(),
+    note: faker.lorem.sentence(),
+  };
+}

package/src/factory/workers/connection.types.ts

@@ -0,0 +1,29 @@
+/** Connection base model */
+export interface ConnectionModel {
+  /** Owner of the connection */
+  ownerId: string;
+  /** USer with which the owner is connected */
+  otherUserId: string;
+  /** Wether the connection is accepted or not */
+  accepted: boolean;
+  /** Date at which the connection was accepted */
+  acceptedAt?: Date;
+  /** Wether the owner did block the other user */
+  blocked: boolean;
+  /** Date at which the connection was blocked */
+  blockedAt?: Date;
+  /** Did the owner initiate the connection */
+  initiator: boolean;
+  /** Message sent to the other user with the connection */
+  message: string;
+  /** Private note the user has on the connection */
+  note: string;
+}
+
+/** Build options for connections */
+export interface ConnectionBuildOptions {
+  /** Wether the connection is accepted or not */
+  accepted?: boolean;
+  /** Wether the owner did block the other user */
+  blocked?: boolean;
+}

package/src/factory/workers/index.ts

@@ -0,0 +1,6 @@
+export * from './user';
+export * from './user.types';
+export * from './connection';
+export * from './connection.types';
+export * from './organization';
+export * from './organization.types';

package/src/factory/workers/organization.ts

@@ -0,0 +1,35 @@
+import { faker } from '@faker-js/faker';
+import {OrganizationModel} from './organization.types';
+
+/** Create a random organization */
+export function organizationFactoryWorker(): OrganizationModel {
+  return {
+    name: faker.company.name(),
+    territory: faker.address.countryCode(),
+    description: faker.company.catchPhrase(),
+    contactInfo: faker.address.streetAddress(),
+    productsInfo: faker.company.catchPhrase(),
+    avatarUrl: faker.internet.url(),
+    coverUrl: faker.internet.url(),
+    membersVisible: faker.datatype.boolean(),
+    searchable: faker.datatype.boolean(),
+    activities: [
+      {
+        id: faker.string.uuid(),
+        translationKey: faker.lorem.word(),
+      },
+    ],
+    members: [
+      {
+        id: faker.string.uuid(),
+        organizationId: faker.string.uuid(),
+        userId: faker.string.uuid(),
+        requested: faker.datatype.boolean(),
+        requestedAt: faker.date.recent(),
+        invited: faker.datatype.boolean(),
+        invitedAt: faker.date.recent(),
+        admin: faker.datatype.boolean(),
+      },
+    ],
+  };
+}

package/src/factory/workers/organization.types.ts

@@ -0,0 +1,53 @@
+/** Organization base model */
+export interface OrganizationModel {
+  /** Name of the organization */
+  name: string;
+  /** ISO Code of the territory in which the organization is located */
+  territory: string;
+  /** Description of the organization */
+  description: string;
+  /** Contact information of the organization */
+  contactInfo: string;
+  /** Product information fo the organization */
+  productsInfo: string;
+  /** URL of the organization avatar */
+  avatarUrl: string;
+  /** URL of the organization cover picture */
+  coverUrl: string;
+  /** Indicates if organization members are visible publicly */
+  membersVisible: boolean;
+  /** Indicates if organization is searchable publicly */
+  searchable: boolean;
+  /** List of activities that the organization has */
+  activities: Array<OrganizationActivityModel>;
+  /** List of organization members */
+  members: Array<OrganizationMemberModel>;
+}
+
+/** Organization activity template */
+export interface OrganizationActivityModel {
+  /** ID of the activity */
+  id: string;
+  /** Translation key to display the activity name */
+  translationKey: string;
+}
+
+/** Organization member */
+export interface OrganizationMemberModel {
+  /** ID of the membership */
+  id: string;
+  /** ID of the organization on which the user has membership */
+  organizationId: string;
+  /** ID of the user */
+  userId: string;
+  /** Did the user accept/request to join the organization */
+  requested: boolean;
+  /** Time at which the user accepted/requested to join the organization */
+  requestedAt: Date;
+  /** Did the user get accepted/invited by an organization admin */
+  invited: boolean;
+  /** Time at which the user got accepted/invited by an organization admin */
+  invitedAt: Date;
+  /** Is the user an admin of the organization */
+  admin: boolean;
+}

package/src/factory/workers/user.ts

@@ -0,0 +1,57 @@
+import { randomUUID } from 'crypto';
+import { faker } from '@faker-js/faker';
+import { UserModel, UserBuildOptions } from './user.types';
+import {
+  generateRegId,
+  generateLocale,
+  generateSignKeyPub,
+  generateSignKeyEncrypted,
+  generateBbEncrypted
+} from 'generators';
+
+/**
+ * Create a random user
+ */
+export function userFactoryWorker(
+  buildOptions: UserBuildOptions = {}
+): UserModel {
+  const firstName = buildOptions.firstName ?? faker.person.firstName();
+  const lastName = buildOptions.lastName ?? faker.person.lastName();
+  const email = faker.internet.email({ firstName, lastName });
+  const userName = faker.internet.userName({ firstName, lastName });
+  const random = Math.random().toString(36).substring(7);
+  const organizationId = buildOptions.organizationId;
+  const organizationMember = buildOptions.member ?? false;
+  const organizationAdmin = buildOptions.admin ?? false;
+  return {
+    firstName,
+    lastName,
+    firstNameLastName: `${firstName}${lastName}`,
+    firstNameSpaceLastName: `${firstName} ${lastName}`,
+    lastNameFirstName: `${lastName}${firstName}`,
+    lastNameSpaceFirstName: `${lastName} ${firstName}`,
+    displayName: `${firstName} ${lastName}`,
+    casualName: `${firstName}`,
+    formalName: `${firstName}`,
+    email: buildOptions.moreRandom ? `${random}${email}` : email,
+    username: buildOptions.moreRandom ? `${random}${userName}` : userName,
+    regId: generateRegId(),
+    locale: generateLocale(),
+    pictureUrl: faker.image.avatar(),
+    organizationId,
+    joinedOrganizationAt: organizationId ? faker.date.recent() : null,
+    organizationAdmin: organizationAdmin,
+    requestedToJoinOrganization: organizationMember || organizationAdmin,
+    acceptedInOrganization: organizationMember || organizationAdmin,
+    linkId: randomUUID(),
+    bbId: randomUUID(),
+    bbEncrypted: generateBbEncrypted(),
+    signKeyEncrypted: generateSignKeyEncrypted(),
+    signKeyPub: generateSignKeyPub(),
+    autoConnect: true,
+    searchable: true,
+    enableUrlScan: true,
+    enableMessageTranslation: true,
+    emailVisibility: true
+  };
+}

package/src/factory/workers/user.types.ts

@@ -0,0 +1,77 @@
+/** User model template */
+export interface UserModel {
+  /** User's first name */
+  firstName: string;
+  /** User's last name */
+  lastName: string;
+  /** @deprecated */
+  firstNameLastName: string;
+  /** @deprecated */
+  firstNameSpaceLastName: string;
+  /** @deprecated */
+  lastNameFirstName: string;
+  /** @deprecated */
+  lastNameSpaceFirstName: string;
+  /** User's regular display name */
+  displayName: string;
+  /** User's casual display name */
+  casualName: string;
+  /** User's formal display name */
+  formalName: string;
+  /** User's email address */
+  email: string;
+  /** @deprecated User's username */
+  username: string;
+  /** User's RegId */
+  regId: string;
+  /** User's locale */
+  locale: string;
+  /** URL opf the user's avatar */
+  pictureUrl: string;
+  /** @deprecated ID of the user's organization */
+  organizationId?: string;
+  /** @deprecated Date at which the user joined the organization */
+  joinedOrganizationAt?: Date | null;
+  /** @deprecated Admin status of the user in the organization */
+  organizationAdmin: boolean;
+  /** @deprecated */
+  requestedToJoinOrganization: boolean;
+  /** @deprecated */
+  acceptedInOrganization: boolean;
+  /** User's ID for QR codes */
+  linkId: string;
+  /** User's BlackBerry ID */
+  bbId: string;
+  /** User's BlackBerry encrypted key */
+  bbEncrypted: string;
+  /** User's signature keys */
+  signKeyEncrypted: string;
+  /** User's public key */
+  signKeyPub: string;
+  /** Enables auto-acceptance of contact requests */
+  autoConnect: boolean;
+  /** Is the user searchable publicly */
+  searchable: boolean;
+  /** Is URL scanning enabled for the user */
+  enableUrlScan: boolean;
+  /** Is message translation enabled for the user */
+  enableMessageTranslation: boolean;
+  /** Is the user's email visible publicly */
+  emailVisibility: boolean;
+}
+
+/** User template build options */
+export interface UserBuildOptions {
+  /** User's first name */
+  firstName?: string;
+  /** User's last name */
+  lastName?: string;
+  /** Id of the organization to which the user is affiliated */
+  organizationId?: string;
+  /** Admin status of the user in his organization */
+  admin?: boolean;
+  /** Membership status of the user in his organization */
+  member?: boolean;
+  /** Add randomness to avoid collisions when generating a large number of entities */
+  moreRandom?: boolean;
+}

package/src/generators/generateAccessToken.ts

@@ -0,0 +1,24 @@
+import { randomUUID } from 'crypto';
+import { sign, SignOptions } from 'jsonwebtoken';
+
+/** Returns an API access token valid in test environment */
+export function generateAccessToken(
+  userId: string,
+  options: SignOptions = {},
+  payload: string | Buffer | object = {}
+): string {
+  const id = userId ?? randomUUID();
+  if (!process.env.JWT_SECRET) throw new Error('Missing JWT signing secret');
+  return sign(
+    typeof payload === 'object' ? { ...payload, user: { id } } : payload,
+    process.env.JWT_SECRET,
+    {
+      expiresIn: '1d',
+      audience: process.env.ACCESS_TOKEN_AUDIENCE,
+      issuer: process.env.ACCESS_TOKEN_ISSUER,
+      subject: id,
+      jwtid: randomUUID(),
+      ...options
+    }
+  );
+}

package/src/generators/generateChatId.ts

@@ -0,0 +1,6 @@
+import crypto from 'crypto';
+
+/** Generate a BlackBerry Spark chatId */
+export function generateChatId(): string {
+  return `${crypto.randomBytes(20).toString('hex')}.1`;
+}

package/src/generators/generateEcdsaKeyPair.ts

@@ -0,0 +1,16 @@
+import {generateKeyPairSync} from 'crypto';
+import {writeFileSync, existsSync, mkdirSync} from 'fs';
+import {resolve} from 'path';
+
+/** Generate a signature key pair for ECDSA */
+export function generateEcdsaKeyPair(): void {
+  const DIR = resolve('certs');
+  if (!existsSync(DIR)) mkdirSync(DIR);
+  const {privateKey, publicKey} = generateKeyPairSync('ec', {
+    namedCurve: 'prime256v1',
+    privateKeyEncoding: {type: 'pkcs8', format: 'pem'},
+    publicKeyEncoding: {type: 'spki', format: 'pem'},
+  });
+  writeFileSync(`${DIR}/ecdsa.key`, privateKey);
+  writeFileSync(`${DIR}/ecdsa.key.pub`, publicKey);
+}

package/src/generators/generateImageBuffer.ts

@@ -0,0 +1,19 @@
+import Jimp from 'jimp';
+import {generateImageBufferOptions} from './generateImageBuffer.types';
+
+/** Generate a binary buffer containing a PNG image */
+export async function generateImageBuffer(
+  options: generateImageBufferOptions = {},
+): Promise<Buffer> {
+  const image = await generateImage(options);
+  return image.getBufferAsync(Jimp.MIME_PNG);
+}
+
+/** Generate the asynchronously image using Jimp */
+async function generateImage(options: generateImageBufferOptions = {}): Promise<Jimp> {
+  return new Promise<Jimp>((resolve) => {
+    new Jimp(options.width ?? 150, options.height ?? 150, function (err, image) {
+      resolve(image);
+    });
+  });
+}

package/src/generators/generateImageBuffer.types.ts

@@ -0,0 +1,7 @@
+/** Options to generate a fake image buffer */
+export interface generateImageBufferOptions {
+  /** Image width */
+  width?: number;
+  /** Image height */
+  height?: number;
+}

package/src/generators/generateKeyPair.ts

@@ -0,0 +1,24 @@
+import {generateKeyPairSync, randomBytes} from 'crypto';
+import {GeneratedKeyPair} from './generateKeyPair.types';
+
+/**
+ * Generate a RSA key pair
+ * @param pass - passphrase used to encrypt the private key (default: generates a random passphrase)
+ */
+export function generateKeyPair(pass: string): GeneratedKeyPair {
+  const passphrase = pass ?? process.env.ID_TOKEN_PASSPHRASE ?? randomBytes(32).toString('base64');
+  const {publicKey, privateKey} = generateKeyPairSync('rsa', {
+    modulusLength: 1024,
+    publicKeyEncoding: {
+      type: 'spki',
+      format: 'pem',
+    },
+    privateKeyEncoding: {
+      type: 'pkcs8',
+      format: 'pem',
+      cipher: 'aes-256-cbc',
+      passphrase,
+    },
+  });
+  return {passphrase, publicKey, privateKey};
+}

package/src/generators/generateKeyPair.types.ts

@@ -0,0 +1,9 @@
+/** Key pair that was generated */
+export interface GeneratedKeyPair {
+  /** PAssphrase used to encrypt the private key */
+  passphrase: string;
+  /** Public key generated, PEM encoded */
+  publicKey: string;
+  /** Private key generated, PEM encoded */
+  privateKey: string;
+}

package/src/generators/generateLocale.ts

@@ -0,0 +1,28 @@
+export const TEST_LOCALES = [
+  'ar',
+  'en-US',
+  'es-ES',
+  'fr-FR',
+  'id-ID',
+  'it-IT',
+  'ja-JP',
+  'km-KH',
+  'ko-KR',
+  'ms-MY',
+  'my-MM',
+  'nl-NL',
+  'pt-PT',
+  'ry-RU',
+  'th-TH',
+  'uk-UA',
+  'vi-VN',
+  'zh-CN',
+  'zh-TW',
+];
+
+/**
+ * Pick up a random locale from the list of testable ones
+ */
+export function generateLocale(): string {
+  return TEST_LOCALES[Math.floor(Math.random() * TEST_LOCALES.length)];
+}

package/src/generators/generateRegId.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates a regID like BBM Spark would
+ */
+export function generateRegId(): string {
+  const length = 18;
+  return Math.floor(Math.random() * Math.pow(10, length))
+    .toString()
+    .padStart(length, '0');
+}

package/src/generators/generateRsaKeyPair.ts

@@ -0,0 +1,12 @@
+import {writeFileSync, mkdirSync, existsSync} from 'fs';
+import path from 'path';
+import {generateKeyPair} from './generateKeyPair';
+
+/** Generate a RSA key pair and store it under "{cwd}/certs/rsa.*" */
+export function generateRsaKeyPair(passphrase: string): void {
+  const DIR = path.resolve('certs');
+  if (!existsSync(DIR)) mkdirSync(DIR);
+  const {publicKey, privateKey} = generateKeyPair(passphrase);
+  writeFileSync(`${DIR}/rsa.key`, privateKey);
+  writeFileSync(`${DIR}/rsa.pub.key`, publicKey);
+}

package/src/generators/generateUserCrypto.ts

@@ -0,0 +1,24 @@
+import crypto from 'crypto';
+
+/**
+ * Generates a fake base64 string that looks like a user public key
+ * /!\ This is not a valid crypto key
+ */
+export function generateSignKeyPub(): string {
+  return crypto.randomBytes(162).toString('base64');
+}
+/**
+ * Generates a fake base64 string that looks like a user encrypted private key
+ * /!\ This is not a valid crypto key
+ */
+export function generateSignKeyEncrypted(): string {
+  return crypto.randomBytes(640).toString('base64');
+}
+
+/**
+ * Generates a fake base64 string that looks like a user encrypted Blackberry Passcode
+ * /!\ This is not a valid crypto key
+ */
+export function generateBbEncrypted(): string {
+  return crypto.randomBytes(80).toString('base64');
+}

package/src/generators/index.ts

@@ -0,0 +1,9 @@
+export * from './generateAccessToken';
+export * from './generateImageBuffer';
+export * from './generateKeyPair';
+export * from './generateLocale';
+export * from './generateRegId';
+export * from './generateRsaKeyPair';
+export * from './generateUserCrypto';
+export * from './generateChatId';
+export * from './generateEcdsaKeyPair';

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './generators';
+export * from './utils';
+export * from './factory';
+export * from './stubs';

package/src/stubs/index.ts

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

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

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

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

@@ -0,0 +1,25 @@
+import {Localizator} from '@gwcdata/node-server-engine/dist/entities/Localizator/Localizator';
+import {stub} from 'sinon';
+import {LocalizatorStub, LocalizatorStubOptions} from './Localizator.types';
+
+const DEFAULT_LOCALE_DATA = {
+  enabled: true,
+  display: 'English',
+  names: {
+    firstNameFirst: true,
+    spacing: true,
+  },
+  cloudTranslationKey: 'en',
+};
+
+/** Stub the Localizator service */
+export function stubLocalizator(overrides: LocalizatorStubOptions): LocalizatorStub {
+  const synchronize = stub(Localizator, 'synchronize').resolves();
+  const init = stub(Localizator, 'init').resolves();
+  const shutdown = stub(Localizator, 'shutdown').resolves();
+  const getLocaleData = stub(Localizator, 'getLocaleData').returns(
+    overrides?.localeData ?? DEFAULT_LOCALE_DATA,
+  );
+  const isValidLocale = stub(Localizator, 'isValidLocale').returns(overrides?.isValid ?? true);
+  return {synchronize, init, shutdown, getLocaleData, isValidLocale};
+}

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

@@ -0,0 +1,24 @@
+import {LocalizatorLocalizationDataElement} from '@gwcdata/node-server-engine';
+import {SinonStub} from 'sinon';
+
+/** Stubbing options for the Localizator */
+export interface LocalizatorStubOptions {
+  /** Forces the return value of the isValidLocale functions  */
+  isValid?: boolean;
+  /** Forces the return value of the getLocaleData functions  */
+  localeData?: LocalizatorLocalizationDataElement;
+}
+
+/** Stubbed properties of the Localizator entity */
+export interface LocalizatorStub {
+  /** Stub of the synchronize method */
+  synchronize: SinonStub;
+  /** Stub of the init method */
+  init: SinonStub;
+  /** Stub of the shutdown method */
+  shutdown: SinonStub;
+  /** Stub of the getLocaleData method */
+  getLocaleData: SinonStub;
+  /** Stub of the isValidLocale method */
+  isValidLocale: SinonStub;
+}