teraslice 2.10.0 → 2.12.0

package/dist/test/services/messaging-spec.js

@@ -0,0 +1,440 @@
+import { jest } from '@jest/globals';
+import events from 'node:events';
+import { debugLogger } from '@terascope/utils';
+import { Messaging, routing } from '../../src/lib/cluster/services/cluster/backends/native/messaging.js';
+describe('messaging module', () => {
+    const logger = debugLogger('messaging');
+    let connected = {};
+    const testExId = '7890';
+    let firstWorkerMsg;
+    let secondWorkerMsg;
+    let clusterFn = () => { };
+    function testMessaging(messaging, fn) {
+        return (...args) => messaging[fn](...args);
+    }
+    class MyCluster extends events.EventEmitter {
+        workers;
+        constructor() {
+            super();
+            this.workers = {
+                first: {
+                    ex_id: testExId,
+                    assignment: 'execution_controller',
+                    connected: true,
+                    send: (msg) => {
+                        firstWorkerMsg = msg;
+                    },
+                    on: (key, fn) => {
+                        clusterFn = fn;
+                    },
+                    removeListener: () => { }
+                },
+                second: {
+                    ex_id: testExId,
+                    assignment: 'worker',
+                    connected: true,
+                    send: (msg) => {
+                        secondWorkerMsg = msg;
+                    },
+                    on: (key, fn) => {
+                        clusterFn = fn;
+                    },
+                    removeListener: () => { }
+                },
+                third: {
+                    ex_id: 'somethingElse',
+                    assignment: 'worker',
+                    connected: true,
+                    send: () => {
+                    },
+                    on: (key, fn) => {
+                        clusterFn = fn;
+                    },
+                    removeListener: () => { }
+                }
+            };
+        }
+    }
+    let emitMsg;
+    const io = {
+        emit: (msg, msgObj) => {
+            emitMsg = { message: msg, data: msgObj };
+        },
+        sockets: {
+            in: (address) => ({
+                emit: (msg, msgObj) => {
+                    const socketMsg = { message: msg, data: msgObj, address };
+                    logger.debug(socketMsg);
+                }
+            }),
+            connected
+        },
+        eio: {
+            clientsCount: 2
+        },
+        close() { }
+    };
+    function getContext(obj) {
+        const emitter = new events.EventEmitter();
+        emitter.setMaxListeners(40);
+        const systemEvents = new events.EventEmitter();
+        systemEvents.setMaxListeners(40);
+        const clusterEmitter = new MyCluster();
+        clusterEmitter.setMaxListeners(40);
+        const config = Object.assign(emitter, obj);
+        const cleanup = () => {
+            emitter.removeAllListeners();
+            systemEvents.removeAllListeners();
+            clusterEmitter.removeAllListeners();
+        };
+        return {
+            sysconfig: {
+                teraslice: {
+                    master_hostname: '127.0.0.1',
+                    port: 47898,
+                    action_timeout: 5000,
+                    network_latency_buffer: 10
+                }
+            },
+            apis: {
+                foundation: {
+                    getSystemEvents: () => systemEvents
+                }
+            },
+            cluster: clusterEmitter,
+            __testingModule: config,
+            cleanup
+        };
+    }
+    beforeEach(() => {
+        firstWorkerMsg = null;
+        secondWorkerMsg = null;
+        connected = {};
+        io.sockets.connected = connected;
+    });
+    afterEach(() => {
+        process.removeAllListeners('message');
+    });
+    it('can make a hostname', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const messaging = new Messaging(testContext, logger, io);
+        const test = testMessaging(messaging, '_makeHostName');
+        expect(test('127.0.0.1', 5647)).toEqual('http://127.0.0.1:5647');
+        expect(test('127.0.0.1:', 5647)).toEqual('http://127.0.0.1:5647');
+        expect(test('http://127.0.0.1', 5647)).toEqual('http://127.0.0.1:5647');
+        expect(test('https://127.0.0.1', 5647)).toEqual('https://127.0.0.1:5647');
+        expect(test('127.0.0.1', 5647, 'v1')).toEqual('http://127.0.0.1:5647/v1');
+        expect(messaging.getHostUrl()).toEqual('http://127.0.0.1:47898');
+        testContext.cleanup();
+    });
+    it('can detect itself and make configurations', () => {
+        function getConfig(type) {
+            const job = JSON.stringify({
+                slicer_hostname: '127.0.0.1',
+                slicer_port: 47898
+            });
+            const testContext = getContext({ env: { assignment: type, job } });
+            const testModule = new Messaging(testContext, logger, io);
+            testContext.cleanup();
+            // @ts-expect-error
+            return testModule._makeConfigurations();
+        }
+        expect(getConfig('node_master')).toEqual({
+            clients: { networkClient: true, ipcClient: false },
+            hostURL: 'http://127.0.0.1:47898',
+            assignment: 'node_master'
+        });
+        expect(getConfig('cluster_master')).toEqual({
+            clients: { networkClient: false, ipcClient: true },
+            assignment: 'cluster_master'
+        });
+        expect(getConfig('assets_service')).toEqual({
+            clients: { networkClient: true, ipcClient: true },
+            hostURL: 'http://127.0.0.1:47898',
+            assignment: 'assets_service'
+        });
+    });
+    it('can be called without errors', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        expect(() => new Messaging(testContext, logger)).not.toThrow();
+        testContext.cleanup();
+    });
+    it('has a router', () => {
+        const routingData = {
+            cluster_master: {
+                node_master: 'network'
+            },
+            node_master: {
+                cluster_process: 'ipc',
+                cluster_master: 'network'
+            },
+            assets_service: { cluster_master: 'ipc' }
+        };
+        expect(routing).toEqual(routingData);
+    });
+    it('can determie path for message', () => {
+        const testContext1 = getContext({ env: { assignment: 'node_master' } });
+        const messaging1 = new Messaging(testContext1, logger, io);
+        const test1 = testMessaging(messaging1, '_determinePathForMessage');
+        const testContext2 = getContext({ env: { assignment: 'cluster_master' } });
+        const messaging2 = new Messaging(testContext2, logger, io);
+        const test2 = testMessaging(messaging2, '_determinePathForMessage');
+        const testContext3 = getContext({ env: { assignment: 'assets_service' } });
+        const messaging3 = new Messaging(testContext3, logger, io);
+        const test3 = testMessaging(messaging3, '_determinePathForMessage');
+        const failureMessage1 = { to: 'theUnknown' };
+        expect(test1({ to: 'cluster_process' })).toEqual('ipc');
+        expect(test1({ to: 'cluster_master' })).toEqual('network');
+        expect(() => test1(failureMessage1)).toThrow();
+        expect(test2({ to: 'node_master' })).toEqual('network');
+        expect(test3({ to: 'cluster_master' })).toEqual('ipc');
+        testContext1.cleanup();
+        testContext2.cleanup();
+        testContext3.cleanup();
+    });
+    it('can get a list of rooms as the cluster_master', () => {
+        connected['some-socket-id'] = {
+            rooms: {
+                'room-a': 'room-a',
+                'room-b': 'room-b'
+            }
+        };
+        connected['another-socket-id'] = {
+            rooms: {
+                'room-1': 'room-1'
+            }
+        };
+        const testContext = getContext({
+            env: {
+                assignment: 'cluster_master'
+            }
+        });
+        const messaging = new Messaging(testContext, logger, io);
+        const rooms = messaging.listRooms();
+        expect(rooms).toEqual(['room-a', 'room-b', 'room-1']);
+        testContext.cleanup();
+    });
+    it('can forward/broadcast messages', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const messaging = new Messaging(testContext, logger, io);
+        // @ts-expect-error
+        messaging._forwardMessage({ to: 'cluster_master', message: 'someEvent' });
+        // should be a network emit msg
+        expect(emitMsg).toEqual({
+            message: 'someEvent',
+            data: {
+                to: 'cluster_master',
+                message: 'someEvent'
+            }
+        });
+        messaging.broadcast('someEvent', { some: 'data' });
+        expect(emitMsg).toEqual({
+            message: 'networkMessage',
+            data: {
+                some: 'data',
+                message: 'someEvent'
+            }
+        });
+        testContext.cleanup();
+    });
+    it('can work with messaging:response messages', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const eventEmitter = testContext.apis.foundation.getSystemEvents();
+        const messaging = new Messaging(testContext, logger, io);
+        const msgId = 'someId';
+        const nodeMsg = { __source: 'node_master', __msgId: msgId, message: 'someMessage' };
+        let emittedData = null;
+        eventEmitter.once(msgId, (data) => {
+            emittedData = data;
+        });
+        // @ts-expect-error
+        messaging._handleResponse(nodeMsg);
+        expect(emittedData).toEqual(nodeMsg);
+        testContext.cleanup();
+    });
+    it('can getClientCounts', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const messaging = new Messaging(testContext, logger, io);
+        expect(messaging.getClientCounts()).toEqual(2);
+        testContext.cleanup();
+    });
+    // This test is broken but it works.
+    // We may not need a test for this because this messaging service
+    // should be replaced with @terascope/teraslice-messaging.
+    // eslint-disable-next-line jest/no-disabled-tests
+    it.skip('can send transactional and non-transactional messages', async () => {
+        const testContext = getContext({ env: { assignment: 'cluster_master' } });
+        const eventEmitter = testContext.apis.foundation.getSystemEvents();
+        const messaging = new Messaging(testContext, logger, io);
+        const workerMsg = {
+            to: 'node_master',
+            node_id: 'someId',
+            message: 'cluster:execution:stop'
+        };
+        const transactionalMsg = Object.assign({}, workerMsg, { response: true });
+        const transactionalErrorMsg = Object.assign({}, workerMsg, {
+            response: true,
+            error: 'someError'
+        });
+        const transactionalTimeoutErrorMsg = Object.assign({}, workerMsg, {
+            response: true,
+            error: 'someError',
+            timeout: 30
+        });
+        function sendEvent(timer) {
+            return new Promise((resolve) => {
+                setTimeout(() => {
+                    let msgId;
+                    if (secondWorkerMsg) {
+                        msgId = secondWorkerMsg.__msgId;
+                    }
+                    else {
+                        msgId = '12345';
+                    }
+                    eventEmitter.emit(msgId, secondWorkerMsg);
+                    resolve(true);
+                }, timer);
+            });
+        }
+        // this is technically a sync message, but a promise is returned for composability
+        // and to act similiar to its transactional counterpart
+        try {
+            const bool = await messaging.send(workerMsg);
+            expect(bool).toEqual(true);
+            expect(firstWorkerMsg).toEqual(workerMsg);
+            const [results] = await Promise.all([messaging.send(transactionalMsg), sendEvent(20)]);
+            expect(results).toEqual(secondWorkerMsg);
+            // testing error scenario
+            try {
+                await Promise.all([messaging.send(transactionalErrorMsg), sendEvent(20)]);
+            }
+            catch (err) {
+                expect(err).toEqual('Error: someError occurred on node: node_master');
+                try {
+                    await Promise.all([
+                        messaging.send(transactionalTimeoutErrorMsg),
+                        sendEvent(100)
+                    ]);
+                }
+                catch (error) {
+                    const messageSent = secondWorkerMsg;
+                    expect(error.message).toEqual(`timeout error while communicating with ${messageSent?.to}, msg: ${messageSent?.message}, data: ${JSON.stringify(messageSent)}`);
+                }
+            }
+        }
+        finally {
+            testContext.cleanup();
+        }
+    });
+    it('can register callbacks and attach them to socket/io', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const messaging = new Messaging(testContext, logger, io);
+        let exitIsCalled = false;
+        const socketSettings = [];
+        messaging.register({
+            event: 'network:connect',
+            identifier: 'node_id',
+            callback: (msg, id, identifier) => {
+                socketSettings.push({ msg, id, identifier });
+                return true;
+            }
+        });
+        messaging.register({
+            event: 'cluster:node:get_port',
+            callback: () => 3452
+        });
+        messaging.register({
+            event: 'child:exit',
+            callback: () => {
+                exitIsCalled = true;
+            }
+        });
+        expect(() => messaging.register({
+            event: 'some:event',
+            callback: () => {
+                exitIsCalled = true;
+            }
+        })).toThrow();
+        const results = { ...messaging.functionMapping };
+        expect(results['cluster:node:get_port']).toBeDefined();
+        expect(typeof results['cluster:node:get_port']).toEqual('function');
+        expect(results['cluster:node:get_port']()).toEqual(3452);
+        // it internally maps 'network:connect' to connect
+        expect(results.connect).toBeDefined();
+        expect(typeof results.connect).toEqual('function');
+        expect(results.connect()).toEqual(true);
+        expect(results.connect.__socketIdentifier).toEqual('node_id');
+        // node master sets the event on the cluster obj
+        testContext.cluster.emit('exit');
+        expect(exitIsCalled).toEqual(true);
+        socketSettings.shift();
+        const socketList = {};
+        const joinList = {};
+        const socket = {
+            rooms: joinList,
+            on: (key, fn) => {
+                socketList[key] = fn;
+            },
+            join: (id) => {
+                joinList[id] = id;
+            },
+            removeListener: (key) => {
+                delete socketList[key];
+            },
+            removeListeners: (key) => {
+                delete socketList[key];
+            }
+        };
+        // @ts-expect-error
+        messaging._registerFns(socket);
+        socketList.connect({ node_id: 'someId' });
+        expect(socketSettings[0]).toEqual({
+            msg: { node_id: 'someId' },
+            id: 'someId',
+            identifier: 'node_id'
+        });
+        testContext.cleanup();
+    });
+    it('can fail if the registering an event for another assignment', () => {
+        const testContext = getContext({ env: { assignment: 'node_master' } });
+        const messaging = new Messaging(testContext, logger, io);
+        const socketSettings = [];
+        expect(() => {
+            messaging.register({
+                // this event is not available to node_master
+                event: 'node:online',
+                identifier: 'node_id',
+                callback: (msg, id, identifier) => {
+                    socketSettings.push({ msg, id, identifier });
+                    return true;
+                }
+            });
+        }).toThrow();
+        testContext.cleanup();
+    });
+    it('can listen and setup server', async () => {
+        const testContext1 = getContext({ env: { assignment: 'node_master' } });
+        const messaging1 = new Messaging(testContext1, logger);
+        const testContext2 = getContext({ env: { assignment: 'cluster_master' } });
+        const messaging2 = new Messaging(testContext2, logger);
+        expect(() => messaging1.listen()).not.toThrow();
+        expect(() => messaging2.listen({ port: 45645 })).not.toThrow();
+        await messaging1.shutdown();
+        await messaging2.shutdown();
+        testContext1.cleanup();
+        testContext2.cleanup();
+    });
+    it('sets up listeners', () => {
+        const testContext1 = getContext({ env: { assignment: 'node_master' } });
+        const messaging1 = new Messaging(testContext1, logger, io);
+        const spy = jest.fn();
+        messaging1.registerChildOnlineHook(spy);
+        testContext1.cluster.emit('online', { id: 'first' });
+        clusterFn({ to: 'cluster_master' });
+        clusterFn({ to: 'node_master' });
+        clusterFn({ to: 'worker' });
+        expect(spy).toHaveBeenCalled();
+        testContext1.cleanup();
+    });
+});
+//# sourceMappingURL=messaging-spec.js.map

package/dist/test/storage/assets_storage-spec.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import { TestContext } from '@terascope/job-components';
+import { createClient } from 'elasticsearch-store';
+import { createS3Client } from '@terascope/file-asset-apis';
+import { AssetsStorage } from '../../src/lib/storage';
+import { TEST_INDEX_PREFIX } from '../test.config';
+describe('AssetsStorage using S3 backend', () => {
+    let storage;
+    const options = {
+        assignment: 'assets_service',
+        clients: [
+            {
+                type: 'elasticsearch-next',
+                async createClient(customConfig, logger) {
+                    const { client } = await createClient(customConfig, logger);
+                    return { client, logger };
+                },
+                endpoint: 'default'
+            },
+            {
+                type: 's3',
+                async createClient(customConfig, logger) {
+                    const client = await createS3Client(customConfig, logger);
+                    return { client, logger };
+                },
+                endpoint: 'default'
+            }
+        ]
+    };
+    const context = new TestContext(`${TEST_INDEX_PREFIX}assets-storage-test`, options);
+    context.sysconfig.terafoundation = {
+        connectors: {
+            'elasticsearch-next': {
+                default: {
+                    node: [process.env.SEARCH_TEST_HOST]
+                }
+            },
+            s3: {
+                default: {
+                    endpoint: process.env.MINIO_HOST,
+                    accessKeyId: process.env.MINIO_ACCESS_KEY,
+                    secretAccessKey: process.env.MINIO_SECRET_KEY,
+                    forcePathStyle: true,
+                    sslEnabled: false,
+                    region: 'test-region'
+                }
+            }
+        }
+    };
+    context.sysconfig.teraslice.asset_storage_connection_type = 's3';
+    context.sysconfig.teraslice.asset_storage_connection = 'default';
+    context.sysconfig.teraslice.api_response_timeout = 30000;
+    beforeAll(async () => {
+        storage = new AssetsStorage(context);
+        await storage.initialize();
+    }, 30000);
+    it('will reject an asset that isn\'t in zip format', async () => {
+        const filePath = 'e2e/test/fixtures/assets/fake_zip.zip';
+        const buffer = fs.readFileSync(filePath);
+        await expect(() => storage.save(buffer)).rejects.toThrow('Failed to save asset. File type not recognized as zip.');
+    });
+    it('will reject an asset if the minimum teraslice version is not met', async () => {
+        const filePath = 'e2e/test/fixtures/assets/test_asset_json.zip';
+        const buffer = fs.readFileSync(filePath);
+        await expect(() => storage.save(buffer)).rejects.toThrow('Asset requires teraslice version 999.9.9 or greater.');
+        expect(await storage.grabS3Info()).toEqual([]);
+    });
+    it('can save an asset to S3', async () => {
+        const filePath = 'e2e/test/fixtures/assets/example_asset_1.zip';
+        const buffer = fs.readFileSync(filePath);
+        const result = await storage.save(buffer);
+        expect(result.assetId).toBe('caf0e5ce7cf1edc864f306b1d9edbad0f7060545');
+    });
+    it('can grab asset info from S3', async () => {
+        const list = await storage.grabS3Info();
+        expect(list).toEqual([{
+                File: 'caf0e5ce7cf1edc864f306b1d9edbad0f7060545.zip',
+                Size: 162711
+            }]);
+    });
+    it('can get an asset from S3', async () => {
+        /// create a buffer copy of example_asset_1.zip to test if it equals what s3 sends back
+        const filePath = 'e2e/test/fixtures/assets/example_asset_1.zip';
+        const buffer = fs.readFileSync(filePath);
+        const assetRecord = await storage.get('caf0e5ce7cf1edc864f306b1d9edbad0f7060545');
+        expect(buffer.equals(assetRecord.blob)).toBe(true);
+        expect(assetRecord.name).toBe('ex1');
+    });
+    it('can delete an asset from S3', async () => {
+        await storage.remove('caf0e5ce7cf1edc864f306b1d9edbad0f7060545');
+        const list = await storage.grabS3Info();
+        expect(list).toBeEmpty();
+    });
+});
+//# sourceMappingURL=assets_storage-spec.js.map

package/dist/test/storage/s3_store-spec.js

@@ -0,0 +1,138 @@
+import fse from 'fs-extra';
+import { TestContext } from '@terascope/job-components';
+import { createS3Client, deleteS3Bucket } from '@terascope/file-asset-apis';
+import { S3Store } from '../../src/lib/storage/backends/s3_store';
+import { TEST_INDEX_PREFIX } from '../test.config';
+describe('S3 backend test', () => {
+    let s3Backend;
+    const contextOptions = {
+        // assignment: 'assets_service',
+        clients: [
+            {
+                type: 's3',
+                createClient: async (customConfig, logger) => {
+                    const client = await createS3Client(customConfig, logger);
+                    return { client, logger };
+                },
+                endpoint: 'default'
+            }
+        ]
+    };
+    const context = new TestContext(`${TEST_INDEX_PREFIX}s3-store-test`, contextOptions);
+    context.sysconfig.terafoundation = {
+        connectors: {
+            s3: {
+                default: {
+                    endpoint: process.env.MINIO_HOST,
+                    accessKeyId: process.env.MINIO_ACCESS_KEY,
+                    secretAccessKey: process.env.MINIO_SECRET_KEY,
+                    forcePathStyle: true,
+                    sslEnabled: false,
+                    region: 'test-region'
+                }
+            }
+        }
+    };
+    describe('->verifyClient', () => {
+        beforeEach(async () => {
+            s3Backend = new S3Store({
+                context,
+                terafoundation: context.sysconfig.terafoundation,
+                connection: 'default',
+                bucket: 'ts-assets'
+            });
+            await s3Backend.initialize();
+        });
+        afterEach(async () => {
+            await s3Backend.shutdown();
+        });
+        it('should throw error trying to verify client if bucket does not exist', async () => {
+            const command = {
+                Bucket: 'ts-assets'
+            };
+            await deleteS3Bucket(s3Backend.api, command);
+            const response = await s3Backend.verifyClient();
+            expect(response).toEqual(false);
+        });
+        it('should be able to verify the client is up', async () => {
+            const response = await s3Backend.verifyClient();
+            expect(response).toEqual(true);
+            const command = {
+                Bucket: 'ts-assets'
+            };
+            await deleteS3Bucket(s3Backend.api, command);
+        });
+    });
+    describe('save, get, and remove assets', () => {
+        beforeAll(async () => {
+            s3Backend = new S3Store({
+                context,
+                terafoundation: context.sysconfig.terafoundation,
+                connection: 'default',
+                bucket: 'ts-assets'
+            });
+            await s3Backend.initialize();
+        });
+        afterAll(async () => {
+            const command = {
+                Bucket: 'ts-assets'
+            };
+            await deleteS3Bucket(s3Backend.api, command);
+            await s3Backend.shutdown();
+        });
+        it('should be able to write in a zip file to ts_assets bucket', async () => {
+            const filePath = 'e2e/test/fixtures/assets/example_asset_1.zip';
+            await s3Backend.save('ex1', fse.readFileSync(filePath), 30000);
+            const result = await s3Backend.list();
+            expect(result[0].File).toBe('ex1.zip');
+        });
+        it('should be able to delete zip file in ts_assets bucket', async () => {
+            await s3Backend.remove('ex1');
+            const result = await s3Backend.list();
+            expect(result).toBeEmpty();
+        });
+        it('should be able to download asset', async () => {
+            const filePath = 'e2e/test/fixtures/assets/example_asset_1.zip';
+            const fileBuffer = fse.readFileSync(filePath);
+            await s3Backend.save('ex1', fileBuffer, 30000);
+            const result = await s3Backend.get('ex1');
+            expect(result.equals(fileBuffer)).toBe(true);
+            await s3Backend.remove('ex1');
+        });
+    });
+    describe('when bucket name is not defined', () => {
+        let bucketName;
+        afterAll(async () => {
+            const command = {
+                Bucket: bucketName
+            };
+            await deleteS3Bucket(s3Backend.api, command);
+            await s3Backend.shutdown();
+        });
+        it('should create a bucket name containing terafoundation.teraslice.name', async () => {
+            bucketName = `ts-assets-${TEST_INDEX_PREFIX}s3-store-test`.replaceAll('_', '-');
+            s3Backend = new S3Store({
+                context,
+                terafoundation: context.sysconfig.terafoundation,
+                connection: 'default',
+                bucket: undefined
+            });
+            await s3Backend.initialize();
+            expect(s3Backend.bucket).toBe(bucketName);
+        });
+        it('should create a bucket name where underscores in teraslice.name are replaced by dashes', async () => {
+            const contextWithUnderscoreName = new TestContext('s3_backend_underscores', contextOptions);
+            contextWithUnderscoreName.sysconfig.terafoundation = context.sysconfig.terafoundation;
+            s3Backend = new S3Store({
+                context: contextWithUnderscoreName,
+                terafoundation: contextWithUnderscoreName.sysconfig.terafoundation,
+                connection: 'default',
+                bucket: undefined
+            });
+            await s3Backend.initialize();
+            expect(s3Backend.bucket).toBe('ts-assets-s3-backend-underscores');
+            bucketName = 'ts-assets-s3-backend-underscores';
+        });
+    });
+});
+//# sourceMappingURL=s3_store-spec.js.map

package/dist/test/test.config.js

@@ -0,0 +1,8 @@
+import { newId } from '../src/lib/utils/id_utils.js';
+const { TEST_INDEX_PREFIX = 'teratest_', ELASTICSEARCH_HOST = 'http://localhost:9200', TERASLICE_CLUSTER_NAME = newId(`${TEST_INDEX_PREFIX}teraslice`, true, 2), ELASTICSEARCH_VERSION = '6.8', SEARCH_TEST_HOST = ELASTICSEARCH_HOST } = process.env;
+process.env.TERASLICE_CLUSTER_NAME = TERASLICE_CLUSTER_NAME;
+process.env.ELASTICSEARCH_HOST = ELASTICSEARCH_HOST;
+process.env.ELASTICSEARCH_VERSION = ELASTICSEARCH_VERSION;
+process.env.SEARCH_TEST_HOST = SEARCH_TEST_HOST;
+export { TEST_INDEX_PREFIX, SEARCH_TEST_HOST, TERASLICE_CLUSTER_NAME, ELASTICSEARCH_VERSION, };
+//# sourceMappingURL=test.config.js.map

package/dist/test/test.setup.js

@@ -0,0 +1,6 @@
+import { jest } from '@jest/globals';
+process.env.USE_DEBUG_LOGGER = 'true';
+process.env.NODE_ENV = 'test';
+// use a larger timeout
+jest.setTimeout(60 * 1000);
+//# sourceMappingURL=test.setup.js.map