@beemo/core/lib/test.js

'use strict';

var _process$env$BEEMO_TE;

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

Object.defineProperty(exports, '__esModule', {
  value: true
});

const common = require('@boost/common');

const test = require('@boost/debug/test');

require('./index.js');

const Driver = require('./Driver.js');

const Script = require('./Script.js');

const Tool = require('./Tool.js');

const ConfigContext = require('./contexts/ConfigContext.js');

const DriverContext = require('./contexts/DriverContext.js');

const ScriptContext = require('./contexts/ScriptContext.js');

const ScaffoldContext = require('./contexts/ScaffoldContext.js');

const TEST_ROOT = new common.Path((_process$env$BEEMO_TE = process.env.BEEMO_TEST_ROOT) !== null && _process$env$BEEMO_TE !== void 0 ? _process$env$BEEMO_TE : process.cwd());

class TestDriver extends Driver.Driver {
  constructor(...args) {
    super(...args);
    this.name = 'test-driver';
  }

}

class TestScript extends Script.Script {
  constructor(...args) {
    super(...args);
    this.name = 'test-script';
  }

  execute() {
    return Promise.resolve();
  }

}

function mockConsole(name) {
  return jest.spyOn(console, name).mockImplementation(() => {});
}

function mockToolConfig() {
  return {
    configure: {
      cleanup: false,
      parallel: true
    },
    debug: false,
    drivers: [],
    execute: {
      concurrency: 1,
      graph: true,
      output: ''
    },
    module: '@local',
    scripts: [],
    settings: {}
  };
}

function mockTool(argv = []) {
  const tool = new Tool.Tool({
    argv,
    cwd: TEST_ROOT
  }); // @ts-expect-error Allow readonly

  tool.debug = test.mockDebugger();
  tool.config = mockToolConfig();
  return tool;
}

function mockDriver(name, tool = null, metadata = {}) {
  const driver = new TestDriver(); // @ts-expect-error For testing purposes

  driver.name = name;
  driver.tool = tool !== null && tool !== void 0 ? tool : mockTool();
  driver.setMetadata(_objectSpread({
    bin: name.toLowerCase(),
    configName: `${name}.json`,
    title: name
  }, metadata));
  return driver;
}

function mockScript(name, tool = null) {
  const script = new TestScript(); // @ts-expect-error For testing purposes

  script.name = name;
  script.tool = tool !== null && tool !== void 0 ? tool : mockTool();
  return script;
}

function stubArgs(options, params = []) {
  return {
    command: [],
    errors: [],
    options,
    params,
    rest: [],
    unknown: {}
  };
}

function stubConfigArgs() {
  return stubArgs({});
}

function stubDriverArgs(fields) {
  return stubArgs(_objectSpread({
    concurrency: 1,
    graph: false,
    workspaces: ''
  }, fields));
}

function stubScaffoldArgs(fields) {
  return stubArgs(_objectSpread({
    dry: false
  }, fields));
}

function stubScriptArgs(fields) {
  return stubArgs(_objectSpread({
    concurrency: 1,
    graph: false,
    workspaces: ''
  }, fields));
}

function applyContext(context) {
  context.args = stubArgs({
    a: true,
    foo: 'bar'
  }, ['baz']);
  context.argv = ['-a', '--foo', 'bar', 'baz'];
  context.cwd = TEST_ROOT;
  context.configModuleRoot = TEST_ROOT;
  context.workspaceRoot = TEST_ROOT;
  context.workspaces = [];
  return context;
}

function stubConfigContext() {
  return applyContext(new ConfigContext.ConfigContext(stubArgs({})));
}

function stubDriverContext(driver) {
  return applyContext(new DriverContext.DriverContext(stubDriverArgs(), driver !== null && driver !== void 0 ? driver : new TestDriver()));
}

function stubScriptContext(script) {
  const context = applyContext(new ScriptContext.ScriptContext(stubScriptArgs(), 'script'));

  if (script) {
    context.setScript(script);
  }

  return context;
}

function stubScaffoldContext(generator = 'generator', action = 'action', name = '') {
  return applyContext(new ScaffoldContext.ScaffoldContext(stubScaffoldArgs(), generator, action, name));
}

function prependRoot(part) {
  return TEST_ROOT.append(part);
}

function getRoot() {
  return TEST_ROOT;
}

function stubExecResult(fields) {
  return _objectSpread({
    all: '',
    command: '',
    escapedCommand: '',
    exitCode: 0,
    failed: false,
    isCanceled: false,
    killed: false,
    signal: undefined,
    stderr: '',
    stdout: '',
    timedOut: false
  }, fields);
}

Object.defineProperty(exports, 'mockDebugger', {
  enumerable: true,
  get: function () {
    return test.mockDebugger;
  }
});
exports.TestDriver = TestDriver;
exports.TestScript = TestScript;
exports.applyContext = applyContext;
exports.getRoot = getRoot;
exports.mockConsole = mockConsole;
exports.mockDriver = mockDriver;
exports.mockScript = mockScript;
exports.mockTool = mockTool;
exports.mockToolConfig = mockToolConfig;
exports.prependRoot = prependRoot;
exports.stubArgs = stubArgs;
exports.stubConfigArgs = stubConfigArgs;
exports.stubConfigContext = stubConfigContext;
exports.stubDriverArgs = stubDriverArgs;
exports.stubDriverContext = stubDriverContext;
exports.stubExecResult = stubExecResult;
exports.stubScaffoldArgs = stubScaffoldArgs;
exports.stubScaffoldContext = stubScaffoldContext;
exports.stubScriptArgs = stubScriptArgs;
exports.stubScriptContext = stubScriptContext;
//# sourceMappingURL=test.js.map