@terascope/job-components/dist/src/test-helpers.js

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = __importDefault(require("path"));
const events_1 = require("events");
const utils_1 = require("@terascope/utils");
function newId(prefix) {
    return `${prefix}-${utils_1.random(10000, 99999)}`;
}
function newTestSlice(request = {}) {
    return {
        slice_id: newId('slice-id'),
        slicer_id: utils_1.random(0, 99999),
        slicer_order: utils_1.random(0, 99999),
        request,
        _created: new Date().toISOString(),
    };
}
exports.newTestSlice = newTestSlice;
function newTestJobConfig(defaults = {}) {
    return Object.assign({
        name: 'test-job',
        apis: [],
        operations: [],
        analytics: false,
        assets: [],
        lifecycle: 'once',
        max_retries: 0,
        probation_window: 30000,
        recycle_worker: 0,
        slicers: 1,
        workers: 1,
    }, defaults);
}
exports.newTestJobConfig = newTestJobConfig;
function newTestExecutionConfig(jobConfig = {}) {
    const exConfig = newTestJobConfig(jobConfig);
    exConfig.slicer_hostname = 'example.com';
    exConfig.slicer_port = utils_1.random(8000, 60000);
    exConfig.ex_id = newId('ex-id');
    exConfig.job_id = newId('job-id');
    return exConfig;
}
exports.newTestExecutionConfig = newTestExecutionConfig;
/**
 * Create a new Execution Context
 * @deprecated use the new WorkerExecutionContext and SlicerExecutionContext
 */
function newTestExecutionContext(type, config) {
    if (type === 'execution_controller') {
        return {
            config,
            queue: [],
            reader: null,
            slicer: () => { },
            dynamicQueueLength: false,
            queueLength: 10000,
            reporter: null,
        };
    }
    return {
        config,
        queue: config.operations.map(() => () => { }),
        reader: () => { },
        slicer: () => { },
        dynamicQueueLength: false,
        queueLength: 10000,
        reporter: null,
    };
}
exports.newTestExecutionContext = newTestExecutionContext;
function getKey(opts) {
    const { type, endpoint = 'default' } = opts;
    if (!utils_1.isString(type))
        throw new Error('A type must be specified when registering a Client');
    return `${type}:${endpoint}`;
}
function setConnectorConfig(sysconfig, opts, config, override = true) {
    const { type, endpoint = 'default' } = opts;
    const { connectors } = sysconfig.terafoundation;
    if (connectors[type] == null)
        connectors[type] = {};
    if (connectors[type][endpoint] == null) {
        connectors[type][endpoint] = config;
    }
    else if (override) {
        connectors[type][endpoint] = config;
    }
    return connectors[type][endpoint];
}
const _cachedClients = new WeakMap();
const _createClientFns = new WeakMap();
class TestContext {
    constructor(testName, options = {}) {
        this.assignment = 'worker';
        this.platform = process.platform;
        this.arch = process.arch;
        const logger = utils_1.debugLogger(testName);
        const events = new events_1.EventEmitter();
        this.name = testName;
        if (options.assignment) {
            this.assignment = options.assignment;
        }
        this.logger = logger;
        this.cluster = {
            worker: {
                id: newId('id'),
            },
        };
        const sysconfig = {
            terafoundation: {
                connectors: {
                    elasticsearch: {
                        default: {},
                    },
                },
            },
            teraslice: {
                action_timeout: 10000,
                analytics_rate: 10000,
                assets_directory: path_1.default.join(process.cwd(), 'assets'),
                cluster_manager_type: 'native',
                hostname: 'localhost',
                index_rollover_frequency: {
                    analytics: 'yearly',
                    state: 'montly',
                },
                master_hostname: 'localhost',
                master: false,
                name: testName,
                network_latency_buffer: 100,
                node_disconnect_timeout: 5000,
                node_state_interval: 5000,
                port: 55678,
                shutdown_timeout: 10000,
                slicer_allocation_attempts: 1,
                slicer_port_range: '55679:56678',
                slicer_timeout: 10000,
                state: {
                    connection: 'default',
                },
                worker_disconnect_timeout: 3000,
                workers: 1,
            },
            _nodeName: `${newId(testName)}__${this.cluster.worker.id}`,
        };
        this.sysconfig = sysconfig;
        // tslint:disable-next-line
        const ctx = this;
        _cachedClients.set(this, {});
        _createClientFns.set(this, {});
        this.apis = {
            foundation: {
                makeLogger(...params) {
                    return logger.child(params[0]);
                },
                getConnection(opts) {
                    const { cached } = opts;
                    const cachedClients = _cachedClients.get(ctx) || {};
                    const key = getKey(opts);
                    if (cached && cachedClients[key] != null) {
                        return cachedClients[key];
                    }
                    const clientFns = _createClientFns.get(ctx) || {};
                    const create = clientFns[key];
                    if (!create)
                        throw new Error(`No client was found for connection "${key}"`);
                    if (!utils_1.isFunction(create)) {
                        const actual = utils_1.getTypeOf(create);
                        throw new Error(`Registered Client for connection "${key}" is not a function, got ${actual}`);
                    }
                    const config = setConnectorConfig(sysconfig, opts, {}, false);
                    const client = create(config, logger, opts);
                    cachedClients[key] = client;
                    _cachedClients.set(ctx, cachedClients);
                    return client;
                },
                getSystemEvents() {
                    return events;
                },
            },
            registerAPI(namespace, apis) {
                this[namespace] = apis;
            },
            setTestClients(clients = []) {
                clients.forEach(clientConfig => {
                    const { create, config = {} } = clientConfig;
                    const clientFns = _createClientFns.get(ctx) || {};
                    const key = getKey(clientConfig);
                    if (!utils_1.isFunction(create)) {
                        const actual = utils_1.getTypeOf(create);
                        throw new Error(`Test Client for connection "${key}" is not a function, got ${actual}`);
                    }
                    logger.trace(`Setting test client for connection "${key}"`, config);
                    clientFns[key] = create;
                    _createClientFns.set(ctx, clientFns);
                    const cachedClients = _cachedClients.get(ctx) || {};
                    delete cachedClients[key];
                    _cachedClients.set(ctx, cachedClients);
                    setConnectorConfig(sysconfig, clientConfig, config, true);
                });
            },
            getTestClients() {
                const cachedClients = _cachedClients.get(ctx) || {};
                const clients = {};
                Object.keys(cachedClients).forEach(key => {
                    const [type, endpoint] = key.split(':');
                    if (clients[type] == null) {
                        clients[type] = {};
                    }
                    clients[type][endpoint] = cachedClients[key];
                });
                return clients;
            },
        };
        this.foundation = {
            getConnection: this.apis.foundation.getConnection,
            getEventEmitter: this.apis.foundation.getSystemEvents,
            makeLogger: this.apis.foundation.makeLogger,
        };
        this.apis.setTestClients(options.clients);
    }
}
exports.TestContext = TestContext;
//# sourceMappingURL=test-helpers.js.map