teraslice 3.3.0 → 3.3.2

package/dist/test/workers/worker/slice-spec.js

@@ -1,333 +0,0 @@
-import { jest } from '@jest/globals';
-import { times } from '@terascope/core-utils';
-import { SliceExecution } from '../../../src/lib/workers/worker/slice.js';
-import { TestContext } from '../helpers/index.js';
-describe('Slice', () => {
-    async function setupSlice(testContext, eventMocks = {}) {
-        await testContext.initialize();
-        await testContext.executionContext.initialize();
-        const [stateStore, analyticsStore] = await Promise.all([
-            testContext.addStateStore(),
-            testContext.addAnalyticsStore(),
-        ]);
-        const slice = new SliceExecution(testContext.context, testContext.executionContext, stateStore, analyticsStore);
-        testContext.attachCleanup(() => slice.shutdown());
-        const sliceConfig = await testContext.newSlice();
-        await slice.initialize(sliceConfig);
-        eventMocks['slice:success'] = jest.fn();
-        eventMocks['slice:finalize'] = jest.fn();
-        eventMocks['slice:failure'] = jest.fn();
-        eventMocks['slice:retry'] = jest.fn();
-        Object.keys(eventMocks).forEach((name) => {
-            const mock = eventMocks[name];
-            slice.events.on(name, mock);
-        });
-        return slice;
-    }
-    describe('with analytics', () => {
-        describe('when the slice succeeds', () => {
-            let slice;
-            let results;
-            let testContext;
-            const eventMocks = {};
-            beforeEach(async () => {
-                testContext = new TestContext({ analytics: true });
-                slice = await setupSlice(testContext, eventMocks);
-                results = await slice.run();
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                // should call of the operations
-                expect(results).toEqual(times(10, () => ({ hi: true })));
-                // should have the correct analytics data
-                expect(slice.analyticsData).toBeObject();
-                expect(slice.analyticsData.memory).toBeArrayOfSize(2);
-                expect(slice.analyticsData.size).toBeArrayOfSize(2);
-                expect(slice.analyticsData.time).toBeArrayOfSize(2);
-                // should call the correct events
-                expect(eventMocks['slice:success']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:success']).toHaveBeenCalled();
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalled();
-                expect(eventMocks['slice:failure']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:retry']).not.toHaveBeenCalled();
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:completed`;
-                return expect(slice.stateStorage.count(query)).resolves.toEqual(1);
-            });
-        });
-    });
-    describe('without analytics', () => {
-        describe('when the slice succeeds', () => {
-            let slice;
-            let results;
-            let testContext;
-            const eventMocks = {};
-            beforeEach(async () => {
-                testContext = new TestContext({ analytics: false });
-                slice = await setupSlice(testContext, eventMocks);
-                results = await slice.run();
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                // should call all of the operations
-                expect(results).toEqual(times(10, () => ({ hi: true })));
-                // should have have the analytics data
-                expect(slice.analyticsData).toBeUndefined();
-                // should call the correct events
-                expect(eventMocks['slice:success']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:success']).toHaveBeenCalled();
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalled();
-                expect(eventMocks['slice:retry']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:failure']).not.toHaveBeenCalled();
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:completed`;
-                return expect(slice.stateStorage.count(query, 0)).resolves.toEqual(1);
-            });
-        });
-        describe('when the slice retries', () => {
-            let slice;
-            let results;
-            let testContext;
-            const eventMocks = {};
-            beforeEach(async () => {
-                testContext = new TestContext({
-                    maxRetries: 3,
-                    analytics: false,
-                    readerErrorAt: [0]
-                });
-                slice = await setupSlice(testContext, eventMocks);
-                results = await slice.run();
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                expect(results).toEqual(times(10, () => ({ hi: true })));
-                // should have have the analytics data
-                expect(slice.analyticsData).toBeUndefined();
-                // should call the correct events
-                expect(eventMocks['slice:retry']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:retry']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:success']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:success']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:failure']).not.toHaveBeenCalled();
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:completed`;
-                return expect(slice.stateStorage.count(query, 0)).resolves.toEqual(1);
-            });
-        });
-        describe('when the slice fails to retry', () => {
-            let slice;
-            let err;
-            let testContext;
-            const eventMocks = {};
-            beforeEach(async () => {
-                testContext = new TestContext({
-                    maxRetries: 3,
-                    analytics: false,
-                    newOps: true,
-                    failOnSliceRetry: true
-                });
-                slice = await setupSlice(testContext, eventMocks);
-                try {
-                    await slice.run();
-                }
-                catch (_err) {
-                    err = _err;
-                }
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                // should have reject with the error
-                expect(err).toBeDefined();
-                const errMsg = err.toString();
-                expect(errMsg).toInclude('Slice failed to retry');
-                expect(errMsg).toInclude('I will not allow it');
-                // should emit the events
-                expect(eventMocks['slice:retry']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:retry']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:failure']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:failure']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:success']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledWith(slice.slice);
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:error`;
-                return expect(slice.stateStorage.count(query, 0)).resolves.toEqual(1);
-            });
-        });
-        describe('when the slice fails', () => {
-            let slice;
-            let testContext;
-            const eventMocks = {};
-            let err;
-            beforeEach(async () => {
-                testContext = new TestContext({
-                    maxRetries: 5,
-                    analytics: false,
-                    opErrorAt: times(6)
-                });
-                slice = await setupSlice(testContext, eventMocks);
-                try {
-                    await slice.run();
-                }
-                catch (_err) {
-                    err = _err;
-                }
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                // should have reject with the error
-                expect(err).toBeDefined();
-                expect(err.toString()).toStartWith('TSError: Slice failed processing, caused by TSError: Bad news bears');
-                // should emit the events
-                expect(eventMocks['slice:retry']).toHaveBeenCalledTimes(5);
-                expect(eventMocks['slice:retry']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:failure']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:failure']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:success']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledWith(slice.slice);
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:error`;
-                return expect(slice.stateStorage.count(query, 0)).resolves.toEqual(1);
-            });
-        });
-        describe('when the slice fails with zero retries', () => {
-            let slice;
-            let testContext;
-            const eventMocks = {};
-            let err;
-            beforeEach(async () => {
-                testContext = new TestContext({
-                    maxRetries: 0,
-                    analytics: false,
-                    opErrorAt: times(5)
-                });
-                slice = await setupSlice(testContext, eventMocks);
-                try {
-                    await slice.run();
-                }
-                catch (_err) {
-                    err = _err;
-                }
-                await Promise.all([
-                    slice.stateStorage.refresh(),
-                    slice.analyticsStorage.refresh(),
-                ]);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the slice correctly', () => {
-                // should have reject with the error
-                expect(err).toBeDefined();
-                expect(err.toString()).toStartWith('TSError: Slice failed processing, caused by TSError: Bad news bears');
-                // should emit the events
-                expect(eventMocks['slice:retry']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:failure']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:failure']).toHaveBeenCalledWith(slice.slice);
-                expect(eventMocks['slice:success']).not.toHaveBeenCalled();
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledTimes(1);
-                expect(eventMocks['slice:finalize']).toHaveBeenCalledWith(slice.slice);
-                // should have the correct state storage
-                const { exId } = slice.executionContext;
-                const query = `ex_id:${exId} AND state:error`;
-                return expect(slice.stateStorage.count(query, 0)).resolves.toEqual(1);
-            });
-        });
-    });
-    describe('when logging the analytics state', () => {
-        describe('when given invalid state', () => {
-            let testContext;
-            let slice;
-            beforeEach(async () => {
-                testContext = new TestContext({ analytics: true });
-                slice = await setupSlice(testContext);
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should not throw an error if given invalid state', async () => {
-                const data = { should: 'break' };
-                await expect(slice._logAnalytics(data)).resolves.not.toThrow();
-            });
-        });
-        describe('when the slice is a string', () => {
-            let testContext;
-            let slice;
-            beforeEach(async () => {
-                testContext = new TestContext({ analytics: true });
-                slice = await setupSlice(testContext);
-                slice.slice = 'hello-there';
-            });
-            afterEach(async () => {
-                await testContext.cleanup();
-            });
-            it('should handle the case when the slice is a string', async () => {
-                // TODO: this is not actually testing a string
-                await expect(slice._logAnalytics({})).resolves.not.toThrow();
-            });
-        });
-    });
-    describe('when marking an invalid slice', () => {
-        let testContext;
-        let slice;
-        beforeEach(async () => {
-            testContext = new TestContext();
-            slice = await setupSlice(testContext);
-            slice.slice = { should: 'break' };
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should throw an error when marking it as failed', async () => {
-            // @ts-expect-error
-            await expect(slice._markFailed(new Error('some error'))).rejects.toThrow(/Failure to update error state/);
-            // @ts-expect-error
-            await expect(slice._markFailed()).rejects.toThrow(/Failure to update error state/);
-        });
-        it('should throw an error when marking it as complete', async () => {
-            // @ts-expect-error
-            await expect(slice._markCompleted()).rejects.toThrow(/Failure to update completed state/);
-        });
-    });
-});
-//# sourceMappingURL=slice-spec.js.map

package/dist/test/workers/worker/worker-spec.js

@@ -1,356 +0,0 @@
-import { jest } from '@jest/globals';
-import 'jest-extended';
-import { pDelay } from '@terascope/core-utils';
-import { ExecutionController } from '@terascope/teraslice-messaging';
-import { findPort } from '../../../src/lib/utils/port_utils.js';
-import { Worker } from '../../../src/lib/workers/worker/index.js';
-import { TestContext } from '../helpers/index.js';
-describe('Worker', () => {
-    async function setupTest(options = {}) {
-        const slicerPort = await findPort();
-        options.slicerPort = slicerPort;
-        const testContext = new TestContext(options);
-        await testContext.initialize();
-        const server = new ExecutionController.Server({
-            port: slicerPort,
-            networkLatencyBuffer: 0,
-            actionTimeout: 1000,
-            workerDisconnectTimeout: 3000
-        });
-        testContext.attachCleanup(() => server.shutdown());
-        await server.start();
-        const worker = new Worker(testContext.context, testContext.executionContext);
-        testContext.attachCleanup(() => worker.shutdown());
-        return { server, worker, testContext };
-    }
-    describe('when running forever', () => {
-        let sliceConfig;
-        let worker;
-        let testContext;
-        let server;
-        let sliceSuccess;
-        let sliceFailure;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-            let shutdownPromise;
-            server.onSliceSuccess((workerId, _msg) => {
-                sliceSuccess = _msg;
-                shutdownPromise = worker.shutdown();
-            });
-            server.onSliceFailure((workerId, _msg) => {
-                sliceFailure = _msg;
-                shutdownPromise = worker.shutdown();
-            });
-            await worker.run();
-            await shutdownPromise;
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should complete the slice', () => {
-            expect(sliceFailure).toBeNil();
-            expect(sliceSuccess).toMatchObject({
-                slice: sliceConfig
-            });
-        });
-    });
-    describe('when running and the execution controller disconnects', () => {
-        let sliceConfig;
-        let worker;
-        let testContext;
-        let server;
-        let sliceSuccess;
-        let sliceFailure;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-            let shutdownPromise;
-            server.onSliceSuccess((workerId, _msg) => {
-                sliceSuccess = _msg;
-                setTimeout(async () => {
-                    shutdownPromise = server.shutdown();
-                });
-            });
-            server.onSliceFailure((workerId, _msg) => {
-                sliceFailure = _msg;
-                setTimeout(async () => {
-                    shutdownPromise = server.shutdown();
-                });
-            });
-            await worker.run();
-            await shutdownPromise;
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should complete the slice', () => {
-            expect(sliceFailure).toBeNil();
-            expect(sliceSuccess).toMatchObject({
-                slice: sliceConfig
-            });
-        });
-    });
-    describe('when a slice is sent from the execution controller', () => {
-        let sliceConfig;
-        let worker;
-        let testContext;
-        let server;
-        let sliceSuccess;
-        let sliceFailure;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-            server.onSliceSuccess((workerId, _msg) => {
-                sliceSuccess = _msg;
-            });
-            server.onSliceFailure((workerId, _msg) => {
-                sliceFailure = _msg;
-            });
-            await worker.runOnce();
-            // avoid on slice events don't fire immediatley now
-            await pDelay(0);
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should complete the slice', () => {
-            expect(sliceFailure).toBeNil();
-            expect(sliceSuccess).toMatchObject({
-                slice: sliceConfig
-            });
-        });
-    });
-    describe('when a new slice is not sent right away', () => {
-        let msg;
-        let sliceConfig;
-        let worker;
-        let testContext;
-        let server;
-        let sliceFailure;
-        let sliceSuccess;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            server.onSliceSuccess((workerId, _msg) => {
-                sliceSuccess = _msg;
-            });
-            server.onSliceFailure((workerId, _msg) => {
-                sliceFailure = _msg;
-            });
-            const msgPromise = server.onceWithTimeout('worker:enqueue');
-            const workerStart = worker.runOnce();
-            await pDelay(500);
-            sliceConfig = await testContext.newSlice();
-            await server.dispatchSlice(sliceConfig, worker.workerId);
-            await workerStart;
-            msg = await msgPromise;
-            await pDelay(100);
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should re-enqueue the worker after receiving the slice complete message', () => {
-            expect(msg).not.toBeNil();
-            expect(sliceSuccess).toMatchObject({
-                slice: sliceConfig
-            });
-            expect(sliceFailure).toBeNil();
-        });
-    });
-    describe('when a slice errors', () => {
-        let worker;
-        let testContext;
-        let server;
-        let sliceFailure;
-        let sliceSuccess;
-        let msg;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            const operations = worker.executionContext.getOperations();
-            for (const op of operations) {
-                // @ts-expect-error
-                op.handle = jest.fn().mockRejectedValue(new Error('Bad news bears'));
-            }
-            server.onSliceSuccess((workerId, _msg) => {
-                sliceSuccess = _msg;
-            });
-            server.onSliceFailure((workerId, _msg) => {
-                sliceFailure = _msg;
-            });
-            const msgPromise = server.onceWithTimeout('worker:enqueue');
-            const sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-            await worker.runOnce();
-            msg = await msgPromise;
-            await pDelay(100);
-        });
-        afterEach(() => testContext.cleanup());
-        it('should return send a slice completed message with an error', () => {
-            expect(sliceSuccess).not.toBeObject();
-            const errMsg = 'TSError: Slice failed processing, caused by TSError: Bad news bears';
-            expect(sliceFailure).toBeObject();
-            expect(sliceFailure.error).toStartWith(errMsg);
-            expect(msg).not.toBeNil();
-        });
-    });
-    describe('when a slice is in-progress and shutdown is called', () => {
-        let workerShutdownEvent;
-        let worker;
-        let testContext;
-        let server;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            workerShutdownEvent = jest.fn();
-            worker.events.once('worker:shutdown', workerShutdownEvent);
-            worker.context.sysconfig.teraslice.shutdown_timeout = 1000;
-            // @ts-expect-error
-            worker.shutdownTimeout = 1000;
-            // @ts-expect-error
-            worker.slice.run = jest.fn(async () => pDelay(500));
-            const sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-        });
-        afterEach(async () => {
-            await testContext.cleanup();
-        });
-        it('should not have a shutdown err', async () => {
-            const promise = server.sendExecutionFinishedToAll(testContext.exId);
-            await expect(worker.shutdown()).resolves.toBeNil();
-            expect(workerShutdownEvent).toHaveBeenCalled();
-            await promise;
-        });
-    });
-    describe('when a slice is in-progress and has to be forced to shutdown', () => {
-        let shutdownErr;
-        let worker;
-        let testContext;
-        let server;
-        beforeEach(async () => {
-            ({ worker, testContext, server } = await setupTest());
-            await worker.initialize();
-            worker.context.sysconfig.teraslice.shutdown_timeout = 500;
-            // @ts-expect-error
-            worker.shutdownTimeout = 500;
-            // @ts-expect-error
-            worker.slice.run = jest.fn(() => pDelay(1000));
-            const sliceConfig = await testContext.newSlice();
-            server.onClientAvailable(() => {
-                server.dispatchSlice(sliceConfig, worker.workerId);
-            });
-            let shutdown;
-            worker.events.once('slice:initialize', () => {
-                shutdown = worker.shutdown().catch((err) => {
-                    shutdownErr = err;
-                });
-            });
-            await worker.run();
-            await shutdown;
-        });
-        afterEach(() => testContext.cleanup());
-        it('shutdown should throw an error', () => {
-            const errMsg = 'Error: Failed to shutdown correctly: Error: Worker shutdown timeout after 0.5 seconds, forcing shutdown';
-            expect(shutdownErr).not.toBeNil();
-            expect(shutdownErr.toString()).toStartWith(errMsg);
-        });
-    });
-    describe('when constructed without nothing', () => {
-        it('should throw an error', () => {
-            expect(() => {
-                // @ts-expect-error
-                new Worker();
-            }).toThrow();
-        });
-    });
-    describe('when testing shutdown', () => {
-        let testContext;
-        let worker;
-        beforeEach(async () => {
-            testContext = new TestContext();
-            await testContext.initialize();
-            worker = new Worker(testContext.context, testContext.executionContext);
-        });
-        afterEach(() => testContext.cleanup());
-        describe('when not initialized', () => {
-            it('should resolve', () => expect(worker.shutdown()).resolves.toBeNil());
-        });
-        describe('when initialized', () => {
-            beforeEach(() => {
-                worker.isInitialized = true;
-            });
-            describe('when controller is already being shutdown', () => {
-                beforeEach(() => {
-                    worker.isShuttingDown = true;
-                });
-                it('should resolve when shutdown passes', async () => {
-                    setTimeout(() => {
-                        worker.events.emit('worker:shutdown:complete');
-                    });
-                    await expect(worker.shutdown()).resolves.toBeNil();
-                });
-                it('should reject when shutdown fails', async () => {
-                    setTimeout(() => {
-                        worker.events.emit('worker:shutdown:complete', new Error('Uh oh'));
-                    });
-                    await expect(worker.shutdown()).rejects.toThrow('Uh oh');
-                });
-            });
-            describe('when everything errors', () => {
-                beforeEach(() => {
-                    worker._waitForSliceToFinish = () => Promise.reject(new Error('Slice Finish Error'));
-                    // @ts-expect-error
-                    worker.stateStorage = {
-                        shutdown: () => Promise.reject(new Error('Store Error'))
-                    };
-                    worker.analyticsStorage = {
-                        // @ts-expect-error
-                        shutdown: async () => Promise.resolve(true)
-                    };
-                    // @ts-expect-error
-                    worker.slice = {
-                        flush: () => Promise.reject(new Error('Flush Error')),
-                        shutdown: () => Promise.reject(new Error('Slice Error'))
-                    };
-                    // @ts-expect-error
-                    worker.client = {
-                        shutdown: () => Promise.reject(new Error('Messenger Error'))
-                    };
-                });
-                it('should reject with all of the errors', async () => {
-                    expect.hasAssertions();
-                    try {
-                        await worker.shutdown();
-                    }
-                    catch (err) {
-                        const errMsg = err.toString();
-                        expect(errMsg).toStartWith('Error: Failed to shutdown correctly');
-                        expect(errMsg).toInclude('Slice Finish Error');
-                        expect(errMsg).toInclude('Store Error');
-                        expect(errMsg).toInclude('Flush Error');
-                        expect(errMsg).toInclude('Slice Error');
-                        expect(errMsg).toInclude('Messenger Error');
-                    }
-                });
-            });
-        });
-    });
-});
-//# sourceMappingURL=worker-spec.js.map