Added bootstrapping tests including occupied node path and concurrent bootstrapping

Author: CMCDragonkai

tests/bin/bootstrap.test.ts

@@ -1,13 +1,11 @@
-import type { RecoveryCode } from '@/keys/types';
 import os from 'os';
 import path from 'path';
 import fs from 'fs';
 import readline from 'readline';
 import Logger, { LogLevel, StreamHandler } from '@matrixai/logger';
-import { Status, errors as statusErrors } from '@/status';
+import { errors as statusErrors } from '@/status';
 import { errors as bootstrapErrors } from '@/bootstrap';
 import * as binUtils from '@/bin/utils';
-import config from '@/config';
 import * as testBinUtils from './utils';
 
 describe('bootstrap', () => {
@@ -26,6 +24,157 @@ describe('bootstrap', () => {
       recursive: true,
     });
   });
+  test(
+    'bootstraps node state',
+    async () => {
+      const password = 'password';
+      const passwordPath = path.join(dataDir, 'password');
+      await fs.promises.writeFile(passwordPath, password);
+      const { exitCode, stdout } = await testBinUtils.pkStdio(
+        [
+          'bootstrap',
+          '--password-file',
+          passwordPath,
+          '--root-key-pair-bits',
+          '1024',
+          '--verbose',
+        ],
+        {
+          PK_NODE_PATH: path.join(dataDir, 'polykey'),
+        },
+        dataDir,
+      );
+      expect(exitCode).toBe(0);
+      const recoveryCode = stdout.trim();
+      expect(
+        recoveryCode.split(' ').length === 12 ||
+          recoveryCode.split(' ').length === 24,
+      ).toBe(true);
+    },
+    global.defaultTimeout,
+  );
+  test('bootstrapping occupied node state', async () => {
+    const password = 'password';
+    await fs.promises.mkdir(path.join(dataDir, 'polykey'));
+    await fs.promises.writeFile(path.join(dataDir, 'polykey', 'test'), '');
+    let exitCode, stdout, stderr;
+    ({ exitCode, stdout, stderr } = await testBinUtils.pkStdio(
+      [
+        'bootstrap',
+        '--node-path',
+        path.join(dataDir, 'polykey'),
+        '--root-key-pair-bits',
+        '1024',
+        '--verbose',
+      ],
+      {
+        PK_PASSWORD: password,
+      },
+      dataDir,
+    ));
+    const errorBootstrapExistingState =
+      new bootstrapErrors.ErrorBootstrapExistingState();
+    expect(exitCode).toBe(errorBootstrapExistingState.exitCode);
+    const stdErrLine = stderr.trim().split('\n').pop();
+    const eOutput = binUtils
+      .outputFormatter({
+        type: 'error',
+        name: errorBootstrapExistingState.name,
+        description: errorBootstrapExistingState.description,
+        message: errorBootstrapExistingState.message,
+      })
+      .trim();
+    expect(stdErrLine).toBe(eOutput);
+    ({ exitCode, stdout, stderr } = await testBinUtils.pkStdio(
+      [
+        'bootstrap',
+        '--node-path',
+        path.join(dataDir, 'polykey'),
+        '--root-key-pair-bits',
+        '1024',
+        '--fresh',
+        '--verbose',
+      ],
+      {
+        PK_PASSWORD: password,
+      },
+      dataDir,
+    ));
+    expect(exitCode).toBe(0);
+    const recoveryCode = stdout.trim();
+    expect(
+      recoveryCode.split(' ').length === 12 ||
+        recoveryCode.split(' ').length === 24,
+    ).toBe(true);
+  });
+  test('concurrent bootstrapping are coalesced', async () => {
+    const password = 'password';
+    const [bootstrapProcess1, bootstrapProcess2] = await Promise.all([
+      testBinUtils.pkSpawn(
+        ['bootstrap', '--root-key-pair-bits', '1024', '--verbose'],
+        {
+          PK_NODE_PATH: path.join(dataDir, 'polykey'),
+          PK_PASSWORD: password,
+        },
+        dataDir,
+        logger.getChild('bootstrapProcess1'),
+      ),
+      testBinUtils.pkSpawn(
+        ['bootstrap', '--root-key-pair-bits', '1024', '--verbose'],
+        {
+          PK_NODE_PATH: path.join(dataDir, 'polykey'),
+          PK_PASSWORD: password,
+        },
+        dataDir,
+        logger.getChild('bootstrapProcess2'),
+      ),
+    ]);
+    // These will be the last line of STDERR
+    // The readline library will automatically trim off newlines
+    let stdErrLine1;
+    let stdErrLine2;
+    const rlErr1 = readline.createInterface(bootstrapProcess1.stderr!);
+    const rlErr2 = readline.createInterface(bootstrapProcess2.stderr!);
+    rlErr1.on('line', (l) => {
+      stdErrLine1 = l;
+    });
+    rlErr2.on('line', (l) => {
+      stdErrLine2 = l;
+    });
+    const [index, exitCode, signal] = await new Promise<
+      [number, number | null, NodeJS.Signals | null]
+    >((resolve) => {
+      bootstrapProcess1.once('exit', (code, signal) => {
+        resolve([0, code, signal]);
+      });
+      bootstrapProcess2.once('exit', (code, signal) => {
+        resolve([1, code, signal]);
+      });
+    });
+    const errorStatusLocked = new statusErrors.ErrorStatusLocked();
+    expect(exitCode).toBe(errorStatusLocked.exitCode);
+    expect(signal).toBe(null);
+    const eOutput = binUtils
+      .outputFormatter({
+        type: 'error',
+        name: errorStatusLocked.name,
+        description: errorStatusLocked.description,
+        message: errorStatusLocked.message,
+      })
+      .trim();
+    // It's either the first or second process
+    if (index === 0) {
+      expect(stdErrLine1).toBeDefined();
+      expect(stdErrLine1).toBe(eOutput);
+      const [exitCode] = await testBinUtils.processExit(bootstrapProcess2);
+      expect(exitCode).toBe(0);
+    } else if (index === 1) {
+      expect(stdErrLine2).toBeDefined();
+      expect(stdErrLine2).toBe(eOutput);
+      const [exitCode] = await testBinUtils.processExit(bootstrapProcess1);
+      expect(exitCode).toBe(0);
+    }
+  });
   test(
     'bootstrap when interrupted, requires fresh on next bootstrap',
     async () => {

tests/bin/utils.ts

@@ -23,6 +23,8 @@ async function pk(args: Array<string>): Promise<any> {
 /**
  * Runs pk command functionally with mocked STDIO
  * Both stdout and stderr are the entire output including newlines
+ * This can only be used serially, because the mocks it relies on are global singletons
+ * If it is used concurrently, the mocking side-effects can conflict
  * @param env Augments env for command execution
  * @param cwd Defaults to temporary directory
  */