libmongocrypt-helper 1.8.0.0.1001 → 1.11.0.0.1001

data/ext/libmongocrypt/libmongocrypt/bindings/node/test/stateMachine.test.js

@@ -1,331 +0,0 @@
-'use strict';
-
-const { EventEmitter, once } = require('events');
-const net = require('net');
-const tls = require('tls');
-const fs = require('fs');
-const { expect } = require('chai');
-const sinon = require('sinon');
-const mongodb = require('mongodb');
-const BSON = mongodb.BSON;
-const StateMachine = require('../lib/stateMachine')({ mongodb }).StateMachine;
-
-describe('StateMachine', function () {
-  class MockRequest {
-    constructor(message, bytesNeeded) {
-      this._bytesNeeded = typeof bytesNeeded === 'number' ? bytesNeeded : 1024;
-      this._message = message;
-      this.endpoint = 'some.fake.host.com';
-      this._kmsProvider = 'aws';
-    }
-
-    get message() {
-      return this._message;
-    }
-
-    get bytesNeeded() {
-      return this._bytesNeeded;
-    }
-
-    get kmsProvider() {
-      return this._kmsProvider;
-    }
-
-    addResponse(buffer) {
-      this._bytesNeeded -= buffer.length;
-    }
-  }
-
-  describe('#markCommand', function () {
-    let runCommandStub;
-    let dbStub;
-    let clientStub;
-
-    beforeEach(function () {
-      this.sinon = sinon.createSandbox();
-      runCommandStub = this.sinon.stub().resolves({});
-      dbStub = this.sinon.createStubInstance(mongodb.Db, {
-        command: runCommandStub
-      });
-      clientStub = this.sinon.createStubInstance(mongodb.MongoClient, {
-        db: dbStub
-      });
-    });
-
-    const command = {
-      encryptedFields: {},
-      a: new BSON.Long('0'),
-      b: new BSON.Int32(0)
-    };
-    const options = { promoteLongs: false, promoteValues: false };
-    const serializedCommand = BSON.serialize(command);
-    const stateMachine = new StateMachine({ bson: BSON });
-    const callback = () => {};
-
-    context('when executing the command', function () {
-      it('does not promote values', function () {
-        stateMachine.markCommand(clientStub, 'test.coll', serializedCommand, callback);
-        expect(runCommandStub.calledWith(command, options)).to.be.true;
-      });
-    });
-  });
-
-  describe('kmsRequest', function () {
-    class MockSocket extends EventEmitter {
-      constructor(callback) {
-        super();
-        this.on('connect', callback);
-      }
-      write() {}
-      destroy() {}
-      end(callback) {
-        Promise.resolve().then(callback);
-      }
-    }
-
-    before(function () {
-      this.sinon = sinon.createSandbox();
-    });
-
-    context('when handling standard kms requests', function () {
-      beforeEach(function () {
-        this.fakeSocket = undefined;
-        this.sinon.stub(tls, 'connect').callsFake((options, callback) => {
-          this.fakeSocket = new MockSocket(callback);
-          return this.fakeSocket;
-        });
-      });
-
-      it('should only resolve once bytesNeeded drops to zero', function (done) {
-        const stateMachine = new StateMachine({ bson: BSON });
-        const request = new MockRequest(Buffer.from('foobar'), 500);
-        let status = 'pending';
-        stateMachine
-          .kmsRequest(request)
-          .then(
-            () => (status = 'resolved'),
-            () => (status = 'rejected')
-          )
-          .catch(() => {});
-
-        this.fakeSocket.emit('connect');
-        setTimeout(() => {
-          expect(status).to.equal('pending');
-          expect(request.bytesNeeded).to.equal(500);
-          expect(request.kmsProvider).to.equal('aws');
-          this.fakeSocket.emit('data', Buffer.alloc(300));
-          setTimeout(() => {
-            expect(status).to.equal('pending');
-            expect(request.bytesNeeded).to.equal(200);
-            this.fakeSocket.emit('data', Buffer.alloc(200));
-            setTimeout(() => {
-              expect(status).to.equal('resolved');
-              expect(request.bytesNeeded).to.equal(0);
-              done();
-            });
-          });
-        });
-      });
-    });
-
-    context('when tls options are provided', function () {
-      context('when the options are insecure', function () {
-        [
-          'tlsInsecure',
-          'tlsAllowInvalidCertificates',
-          'tlsAllowInvalidHostnames',
-          'tlsDisableOCSPEndpointCheck',
-          'tlsDisableCertificateRevocationCheck'
-        ].forEach(function (option) {
-          context(`when the option is ${option}`, function () {
-            const stateMachine = new StateMachine({
-              bson: BSON,
-              tlsOptions: { aws: { [option]: true } }
-            });
-            const request = new MockRequest(Buffer.from('foobar'), 500);
-
-            it('rejects with the validation error', function (done) {
-              stateMachine.kmsRequest(request).catch(err => {
-                expect(err.message).to.equal(`Insecure TLS options prohibited for aws: ${option}`);
-                done();
-              });
-            });
-          });
-        });
-      });
-
-      context('when the options are secure', function () {
-        context('when providing tlsCertificateKeyFile', function () {
-          const stateMachine = new StateMachine({
-            bson: BSON,
-            tlsOptions: { aws: { tlsCertificateKeyFile: 'test.pem' } }
-          });
-          const request = new MockRequest(Buffer.from('foobar'), -1);
-          const buffer = Buffer.from('foobar');
-          let connectOptions;
-
-          it('sets the cert and key options in the tls connect options', function (done) {
-            this.sinon.stub(fs, 'readFileSync').callsFake(fileName => {
-              expect(fileName).to.equal('test.pem');
-              return buffer;
-            });
-            this.sinon.stub(tls, 'connect').callsFake((options, callback) => {
-              connectOptions = options;
-              this.fakeSocket = new MockSocket(callback);
-              return this.fakeSocket;
-            });
-            stateMachine.kmsRequest(request).then(function () {
-              expect(connectOptions.cert).to.equal(buffer);
-              expect(connectOptions.key).to.equal(buffer);
-              done();
-            });
-            this.fakeSocket.emit('data', Buffer.alloc(0));
-          });
-        });
-
-        context('when providing tlsCAFile', function () {
-          const stateMachine = new StateMachine({
-            bson: BSON,
-            tlsOptions: { aws: { tlsCAFile: 'test.pem' } }
-          });
-          const request = new MockRequest(Buffer.from('foobar'), -1);
-          const buffer = Buffer.from('foobar');
-          let connectOptions;
-
-          it('sets the ca options in the tls connect options', function (done) {
-            this.sinon.stub(fs, 'readFileSync').callsFake(fileName => {
-              expect(fileName).to.equal('test.pem');
-              return buffer;
-            });
-            this.sinon.stub(tls, 'connect').callsFake((options, callback) => {
-              connectOptions = options;
-              this.fakeSocket = new MockSocket(callback);
-              return this.fakeSocket;
-            });
-            stateMachine.kmsRequest(request).then(function () {
-              expect(connectOptions.ca).to.equal(buffer);
-              done();
-            });
-            this.fakeSocket.emit('data', Buffer.alloc(0));
-          });
-        });
-
-        context('when providing tlsCertificateKeyFilePassword', function () {
-          const stateMachine = new StateMachine({
-            bson: BSON,
-            tlsOptions: { aws: { tlsCertificateKeyFilePassword: 'test' } }
-          });
-          const request = new MockRequest(Buffer.from('foobar'), -1);
-          let connectOptions;
-
-          it('sets the passphrase option in the tls connect options', function (done) {
-            this.sinon.stub(tls, 'connect').callsFake((options, callback) => {
-              connectOptions = options;
-              this.fakeSocket = new MockSocket(callback);
-              return this.fakeSocket;
-            });
-            stateMachine.kmsRequest(request).then(function () {
-              expect(connectOptions.passphrase).to.equal('test');
-              done();
-            });
-            this.fakeSocket.emit('data', Buffer.alloc(0));
-          });
-        });
-      });
-    });
-
-    afterEach(function () {
-      this.sinon.restore();
-    });
-  });
-
-  describe('Socks5 support', function () {
-    let socks5srv;
-    let hasTlsConnection;
-    let withUsernamePassword;
-
-    beforeEach(async () => {
-      hasTlsConnection = false;
-      socks5srv = net.createServer(async socket => {
-        if (withUsernamePassword) {
-          expect(await once(socket, 'data')).to.deep.equal([Buffer.from('05020002', 'hex')]);
-          socket.write(Buffer.from('0502', 'hex'));
-          expect(await once(socket, 'data')).to.deep.equal([
-            Buffer.concat([
-              Buffer.from('0103', 'hex'),
-              Buffer.from('foo'),
-              Buffer.from('03', 'hex'),
-              Buffer.from('bar')
-            ])
-          ]);
-          socket.write(Buffer.from('0100', 'hex'));
-        } else {
-          expect(await once(socket, 'data')).to.deep.equal([Buffer.from('050100', 'hex')]);
-          socket.write(Buffer.from('0500', 'hex'));
-        }
-        expect(await once(socket, 'data')).to.deep.equal([
-          Buffer.concat([
-            Buffer.from('0501000312', 'hex'),
-            Buffer.from('some.fake.host.com'),
-            Buffer.from('01bb', 'hex')
-          ])
-        ]);
-        socket.write(Buffer.from('0500007f0000010100', 'hex'));
-        expect((await once(socket, 'data'))[0][1]).to.equal(3); // TLS handshake version byte
-        hasTlsConnection = true;
-        socket.end();
-      });
-      socks5srv.listen(0);
-      await once(socks5srv, 'listening');
-    });
-
-    afterEach(() => {
-      socks5srv.close();
-    });
-
-    it('should create HTTPS connections through a Socks5 proxy (no proxy auth)', async function () {
-      const stateMachine = new StateMachine({
-        bson: BSON,
-        proxyOptions: {
-          proxyHost: 'localhost',
-          proxyPort: socks5srv.address().port
-        }
-      });
-
-      const request = new MockRequest(Buffer.from('foobar'), 500);
-      try {
-        await stateMachine.kmsRequest(request);
-      } catch (err) {
-        expect(err.name).to.equal('MongoCryptError');
-        expect(err.originalError.code).to.equal('ECONNRESET');
-        expect(hasTlsConnection).to.equal(true);
-        return;
-      }
-      expect.fail('missed exception');
-    });
-
-    it('should create HTTPS connections through a Socks5 proxy (username/password auth)', async function () {
-      withUsernamePassword = true;
-      const stateMachine = new StateMachine({
-        bson: BSON,
-        proxyOptions: {
-          proxyHost: 'localhost',
-          proxyPort: socks5srv.address().port,
-          proxyUsername: 'foo',
-          proxyPassword: 'bar'
-        }
-      });
-
-      const request = new MockRequest(Buffer.from('foobar'), 500);
-      try {
-        await stateMachine.kmsRequest(request);
-      } catch (err) {
-        expect(err.name).to.equal('MongoCryptError');
-        expect(err.originalError.code).to.equal('ECONNRESET');
-        expect(hasTlsConnection).to.equal(true);
-        return;
-      }
-      expect.fail('missed exception');
-    });
-  });
-});

data/ext/libmongocrypt/libmongocrypt/bindings/node/test/tools/chai-addons.js

@@ -1,8 +0,0 @@
-'use strict';
-
-// configure chai
-const chai = require('chai');
-chai.use(require('sinon-chai'));
-chai.use(require('chai-subset'));
-
-chai.config.truncateThreshold = 0;

data/ext/libmongocrypt/libmongocrypt/bindings/node/test/tools/mongodb_reporter.js

@@ -1,325 +0,0 @@
-//@ts-check
-'use strict';
-const mocha = require('mocha');
-const chalk = require('chalk');
-
-chalk.level = 3;
-
-const {
-  EVENT_RUN_BEGIN,
-  EVENT_RUN_END,
-  EVENT_TEST_FAIL,
-  EVENT_TEST_PASS,
-  EVENT_SUITE_BEGIN,
-  EVENT_SUITE_END,
-  EVENT_TEST_PENDING,
-  EVENT_TEST_BEGIN,
-  EVENT_TEST_END
-} = mocha.Runner.constants;
-
-const fs = require('fs');
-const os = require('os');
-
-/**
- * @typedef {object} MongoMochaSuiteExtension
- * @property {Date} timestamp - suite start date
- * @property {string} stdout - capture of stdout
- * @property {string} stderr - capture of stderr
- * @property {MongoMochaTest} test - capture of stderr
- * @typedef {object} MongoMochaTestExtension
- * @property {Date} startTime - test start date
- * @property {Date} endTime - test end date
- * @property {number} elapsedTime - difference between end and start
- * @property {Error} [error] - The possible error from a test
- * @property {true} [skipped] - Set if test was skipped
- * @typedef {MongoMochaSuiteExtension & Mocha.Suite} MongoMochaSuite
- * @typedef {MongoMochaTestExtension & Mocha.Test} MongoMochaTest
- */
-
-// Turn this on if you have to debug this custom reporter!
-let REPORT_TO_STDIO = false;
-
-function captureStream(stream) {
-  var oldWrite = stream.write;
-  var buf = '';
-  stream.write = function (chunk) {
-    buf += chunk.toString(); // chunk is a String or Buffer
-    oldWrite.apply(stream, arguments);
-  };
-
-  return {
-    unhook: function unhook() {
-      stream.write = oldWrite;
-      return buf;
-    },
-    captured: function () {
-      return buf;
-    }
-  };
-}
-
-/**
- * @param {Mocha.Runner} runner
- * @this {any}
- */
-class MongoDBMochaReporter extends mocha.reporters.Spec {
-  constructor(runner) {
-    super(runner);
-    /** @type {Map<string, {suite: MongoMochaSuite, stdout?: any, stderr?: any}>} */
-    this.suites = new Map();
-    this.xunitWritten = false;
-    runner.on(EVENT_RUN_BEGIN, () => this.start());
-    runner.on(EVENT_RUN_END, () => this.end());
-    runner.on(EVENT_SUITE_BEGIN, suite => this.onSuite(suite));
-    runner.on(EVENT_TEST_BEGIN, test => this.onTest(test));
-    runner.on(EVENT_TEST_PASS, test => this.pass(test));
-    runner.on(EVENT_TEST_FAIL, (test, error) => this.fail(test, error));
-    runner.on(EVENT_TEST_PENDING, test => this.pending(test));
-    runner.on(EVENT_SUITE_END, suite => this.suiteEnd(suite));
-    runner.on(EVENT_TEST_END, test => this.testEnd(test));
-
-    process.on('SIGINT', () => this.end(true));
-  }
-  start() {}
-
-  end(ctrlC) {
-    try {
-      if (ctrlC) console.log('emergency exit!');
-      const output = { testSuites: [] };
-
-      for (const [id, [className, { suite }]] of [...this.suites.entries()].entries()) {
-        let totalSuiteTime = 0;
-        let testCases = [];
-        let failureCount = 0;
-
-        const tests = /** @type {MongoMochaTest[]}*/ (suite.tests);
-        for (const test of tests) {
-          let time = test.elapsedTime / 1000;
-          time = Number.isNaN(time) ? 0 : time;
-
-          totalSuiteTime += time;
-          failureCount += test.state === 'failed' ? 1 : 0;
-
-          /** @type {string | Date | number} */
-          let startTime = test.startTime;
-          startTime = startTime ? startTime.toISOString() : 0;
-
-          /** @type {string | Date | number} */
-          let endTime = test.endTime;
-          endTime = endTime ? endTime.toISOString() : 0;
-
-          let error = test.error;
-          let failure = error
-            ? {
-                type: error.constructor.name,
-                message: error.message,
-                stack: error.stack
-              }
-            : undefined;
-
-          let skipped = !!test.skipped;
-
-          testCases.push({
-            name: test.title,
-            className,
-            time,
-            startTime,
-            endTime,
-            skipped,
-            failure
-          });
-        }
-
-        /** @type {string | Date | number} */
-        let timestamp = suite.timestamp;
-        timestamp = timestamp ? timestamp.toISOString().split('.')[0] : '';
-
-        output.testSuites.push({
-          package: suite.file.includes('integration') ? 'Integration' : 'Unit',
-          id,
-          name: className,
-          timestamp,
-          hostname: os.hostname(),
-          tests: suite.tests.length,
-          failures: failureCount,
-          errors: '0',
-          time: totalSuiteTime,
-          testCases,
-          stdout: suite.stdout,
-          stderr: suite.stderr
-        });
-      }
-
-      if (!this.xunitWritten) {
-        fs.writeFileSync('xunit.xml', outputToXML(output), { encoding: 'utf8' });
-      }
-      this.xunitWritten = true;
-      console.log(chalk.bold('wrote xunit.xml'));
-    } catch (error) {
-      console.error(chalk.red(`Failed to output xunit report! ${error}`));
-    } finally {
-      if (ctrlC) process.exit(1);
-    }
-  }
-
-  /**
-   * @param {MongoMochaSuite} suite
-   */
-  onSuite(suite) {
-    if (suite.root) return;
-    if (!this.suites.has(suite.fullTitle())) {
-      suite.timestamp = new Date();
-      this.suites.set(suite.fullTitle(), {
-        suite,
-        stdout: captureStream(process.stdout),
-        stderr: captureStream(process.stderr)
-      });
-    } else {
-      console.warn(`${chalk.yellow('WARNING:')} ${suite.fullTitle()} started twice`);
-    }
-  }
-
-  /**
-   * @param {MongoMochaSuite} suite
-   */
-  suiteEnd(suite) {
-    if (suite.root) return;
-    const currentSuite = this.suites.get(suite.fullTitle());
-    if (!currentSuite) {
-      console.error('Suite never started >:(');
-      process.exit(1);
-    }
-    if (currentSuite.stdout || currentSuite.stderr) {
-      suite.stdout = currentSuite.stdout.unhook();
-      suite.stderr = currentSuite.stderr.unhook();
-      delete currentSuite.stdout;
-      delete currentSuite.stderr;
-    }
-  }
-
-  /**
-   * @param {MongoMochaTest} test
-   */
-  onTest(test) {
-    test.startTime = new Date();
-  }
-
-  /**
-   * @param {MongoMochaTest} test
-   */
-  testEnd(test) {
-    test.endTime = new Date();
-    test.elapsedTime = Number(test.endTime) - Number(test.startTime);
-  }
-
-  /**
-   * @param {MongoMochaTest} test
-   */
-  pass(test) {
-    if (REPORT_TO_STDIO) console.log(chalk.green(`✔ ${test.fullTitle()}`));
-  }
-
-  /**
-   * @param {MongoMochaTest} test
-   * @param {Error} error
-   */
-  fail(test, error) {
-    if (REPORT_TO_STDIO) console.log(chalk.red(`⨯ ${test.fullTitle()} -- ${error.message}`));
-    test.error = error;
-  }
-
-  /**
-   * @param {MongoMochaTest & {skipReason?: string}} test
-   */
-  pending(test) {
-    if (REPORT_TO_STDIO) console.log(chalk.cyan(`↬ ${test.fullTitle()}`));
-    if (typeof test.skipReason === 'string') {
-      console.log(chalk.cyan(`${'  '.repeat(test.titlePath().length + 1)}↬ ${test.skipReason}`));
-    }
-    test.skipped = true;
-  }
-}
-
-module.exports = MongoDBMochaReporter;
-
-function replaceIllegalXMLCharacters(string) {
-  // prettier-ignore
-  return String(string)
-    .split('"').join('＂')
-    .split('<').join('﹤')
-    .split('>').join('﹥')
-    .split('&').join('﹠');
-}
-
-const ANSI_ESCAPE_REGEX =
-  // eslint-disable-next-line no-control-regex
-  /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
-function outputToXML(output) {
-  function cdata(str) {
-    return `<![CDATA[${String(str)
-      .split(ANSI_ESCAPE_REGEX)
-      .join('')
-      .split(']]>')
-      .join('\\]\\]\\>')}]]>`;
-  }
-
-  function makeTag(name, attributes, selfClose, content) {
-    const attributesString = Object.entries(attributes || {})
-      .map(([k, v]) => `${k}="${replaceIllegalXMLCharacters(v)}"`)
-      .join(' ');
-    let tag = `<${name}${attributesString ? ' ' + attributesString : ''}`;
-    if (selfClose) return tag + '/>\n';
-    else tag += '>';
-    if (content) return tag + content + `</${name}>`;
-    return tag;
-  }
-
-  let s =
-    '<?xml version="1.0" encoding="UTF-8"?>\n<?xml-model href="./test/tools/reporter/xunit.xsd" ?>\n<testsuites>\n';
-
-  for (const suite of output.testSuites) {
-    s += makeTag('testsuite', {
-      package: suite.package,
-      id: suite.id,
-      name: suite.name,
-      timestamp: suite.timestamp,
-      hostname: suite.hostname,
-      tests: suite.tests,
-      failures: suite.failures,
-      errors: suite.errors,
-      time: suite.time
-    });
-    s += '\n\t' + makeTag('properties') + '</properties>\n'; // can put metadata here?
-    for (const test of suite.testCases) {
-      s +=
-        '\t' +
-        makeTag(
-          'testcase',
-          {
-            name: test.name,
-            classname: test.className,
-            time: test.time,
-            start: test.startTime,
-            end: test.endTime
-          },
-          !test.failure && !test.skipped
-        );
-      if (test.failure) {
-        s +=
-          '\n\t\t' +
-          makeTag('failure', { type: test.failure.type }, false, cdata(test.failure.stack)) +
-          '\n';
-        s += `\t</testcase>\n`;
-      }
-      if (test.skipped) {
-        s += makeTag('skipped', {}, true);
-        s += `\t</testcase>\n`;
-      }
-    }
-    s += '\t' + makeTag('system-out', {}, false, cdata(suite.stdout)) + '\n';
-    s += '\t' + makeTag('system-err', {}, false, cdata(suite.stderr)) + '\n';
-    s += `</testsuite>\n`;
-  }
-
-  return s + '</testsuites>\n';
-}