@forge/cache 1.0.2 → 1.0.3-next.0-experimental-ab129b0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/cache",
-  "version": "1.0.2",
+  "version": "1.0.3-next.0-experimental-ab129b0",
   "description": "Forge Cache methods",
   "author": "Atlassian",
   "license": "SEE LICENSE IN LICENSE.txt",
@@ -21,7 +21,7 @@
     "tmp": "^0.2.3"
   },
   "dependencies": {
-    "@forge/api": "^6.0.2",
+    "@forge/api": "^6.0.3-next.0-experimental-ab129b0",
     "agentkeepalive": "^4.5.0",
     "node-fetch": "2.7.0",
     "object-sizeof": "^2.6.5"

package/out/__test__/cache.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cache.test.d.ts.map

package/out/__test__/cache.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.test.d.ts","sourceRoot":"","sources":["../../src/__test__/cache.test.ts"],"names":[],"mappings":""}

package/out/__test__/cache.test.js

@@ -1,358 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
-const cache_1 = require("../cache");
-jest.mock('node-fetch');
-const fetchMock = node_fetch_1.default;
-describe('Forge Cache', () => {
-    beforeEach(() => {
-        global['__forge_runtime__'] = {
-            proxy: {
-                token: 'token',
-                url: 'https://proxy.atlassian.com'
-            },
-            rms: {
-                url: 'https://dev.services.atlassian.com',
-                host: 'rockmelon-storage.dev.atl-paas.net'
-            },
-            tracing: {
-                traceId: 'trace-id-test',
-                spanId: 'span-id-test'
-            }
-        };
-    });
-    it('chooses the v2 fetch based on runtime', async () => {
-        const cacheClient = (0, cache_1.connect)();
-        await cacheClient['client']('asdf');
-        expect(fetchMock).toHaveBeenCalled();
-    });
-});
-describe('createFetch', () => {
-    it('fetch fails when rms config is not available', async () => {
-        global['__forge_runtime__'] = {
-            proxy: {
-                token: 'token',
-                url: 'https://proxy.atlassian.com'
-            }
-        };
-        await expect((0, cache_1.createFetchRmsRuntimeV2)()).rejects.toThrowError(new Error('RMS config not available.'));
-    });
-    it('creates a fetch that adds the right headers and url', async () => {
-        global['__forge_runtime__'] = {
-            proxy: {
-                token: 'token',
-                url: 'https://proxy.atlassian.com'
-            },
-            rms: {
-                url: 'https://dev.services.atlassian.com',
-                host: 'rockmelon-storage.dev.atl-paas.net'
-            },
-            tracing: {
-                traceId: 'trace-id-test',
-                spanId: 'span-id-test'
-            }
-        };
-        const fetch = (0, cache_1.createFetchRmsRuntimeV2)();
-        await fetch('path');
-        const [absoluteUrl, options] = fetchMock.mock.lastCall ?? ['', {}];
-        expect(absoluteUrl.toString()).toEqual('https://rms/path');
-        expect((options?.agent)['passthrough']['keepAlive']).toBeTruthy();
-        expect(options?.headers).toMatchObject({
-            Authorization: 'Bearer token',
-            Host: 'rockmelon-storage.dev.atl-paas.net',
-            'x-b3-traceid': 'trace-id-test',
-            'x-b3-spanid': 'span-id-test'
-        });
-    });
-});
-describe('Cache', () => {
-    function buildCache() {
-        const fetch = jest.fn();
-        const cache = new cache_1.Cache(fetch);
-        return { cache, fetch };
-    }
-    describe('set', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({}), status: 200 });
-            await cache.set('key', 'value');
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with ttl', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({}), status: 200 });
-            await cache.set('key', 'value', { ttlSeconds: 100 });
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.set('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure with error code', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({
-                ok: false,
-                text: async () => JSON.stringify({ error: { code: 'NOT_ALLOWED', title: 'Invalid operation' } }),
-                status: 400
-            });
-            await expect(cache.set('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new cache_1.ApiError(400, 'NOT_ALLOWED', '"title":"Invalid operation"'));
-        });
-    });
-    describe('setIfNotExists', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 'OK' }), status: 200 });
-            const result = await cache.setIfNotExists('key', 'value');
-            expect(result).toEqual('OK');
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key exists', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
-            const result = await cache.setIfNotExists('key', 'value');
-            expect(result).toBeNull();
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with ttl', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 'OK' }), status: 200 });
-            await cache.setIfNotExists('key', 'value', { ttlSeconds: 100 });
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.setIfNotExists('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('get', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ response: 'asdfasdf' }),
-                status: 200
-            });
-            const result = await cache.get('key');
-            expect(result).toEqual('asdfasdf');
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key does not exist', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
-            const result = await cache.get('key');
-            expect(result).toBeNull();
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.get('key')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('getAndSet', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ response: 'oldValue' }),
-                status: 200
-            });
-            const result = await cache.getAndSet('key', 'newValue');
-            expect(result).toEqual('oldValue');
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key does not exist', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
-            const result = await cache.getAndSet('key', 'value');
-            expect(result).toBeNull();
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with ttl', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({
-                ok: true,
-                text: async () => JSON.stringify({ response: 'oldValue' }),
-                status: 200
-            });
-            await cache.getAndSet('key', 'newValue', { ttlSeconds: 100 });
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.getAndSet('key', 'value', { ttlSeconds: 100 })).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('incrementAndGet', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
-            const result = await cache.incrementAndGet('key');
-            expect(result).toEqual(0);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with ttl', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
-            const result = await cache.incrementAndGet('key', { ttlSeconds: 100 });
-            expect(result).toEqual(0);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key exists', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 11 }), status: 200 });
-            const result = await cache.incrementAndGet('key');
-            expect(result).toEqual(11);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.incrementAndGet('key')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('decrementAndGet', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
-            const result = await cache.decrementAndGet('key');
-            expect(result).toEqual(0);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with ttl', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
-            const result = await cache.decrementAndGet('key', { ttlSeconds: 100 });
-            expect(result).toEqual(0);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key exists', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 11 }), status: 200 });
-            const result = await cache.decrementAndGet('key');
-            expect(result).toEqual(11);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.decrementAndGet('key')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('delete', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 1 }), status: 200 });
-            const result = await cache.delete('key');
-            expect(result).toEqual(1);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.delete('key')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('scan', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            const expectedResponse = { cursor: '0', keys: ['key1', 'key2'] };
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify(expectedResponse), status: 200 });
-            const actualResponse = await cache.scan('key*');
-            expect(actualResponse).toEqual(expectedResponse);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with cursor', async () => {
-            const { cache, fetch } = buildCache();
-            const expectedResponse = { cursor: '0', keys: ['key2'] };
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify(expectedResponse), status: 200 });
-            const actualResponse = await cache.scan('key*', { cursor: '1' });
-            expect(actualResponse).toEqual(expectedResponse);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success with count', async () => {
-            const { cache, fetch } = buildCache();
-            const expectedResponse = { cursor: '0', keys: ['key1'] };
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify(expectedResponse), status: 200 });
-            const actualResponse = await cache.scan('key*', { count: 1 });
-            expect(actualResponse).toEqual(expectedResponse);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.scan('key*', { cursor: '0', count: 2 })).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('leftPush', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 1 }), status: 200 });
-            const result = await cache.leftPush('list', 'value');
-            expect(result).toEqual(1);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.leftPush('list', 'value')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('rightPop', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 'value' }), status: 200 });
-            const result = await cache.rightPop('list');
-            expect(result).toEqual('value');
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key does not exist', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
-            const result = await cache.rightPop('list');
-            expect(result).toBeNull();
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.rightPop('list')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-    describe('listLength', () => {
-        it('handles success', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 2 }), status: 200 });
-            const result = await cache.listLength('list');
-            expect(result).toBe(2);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles success when key does not exist', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: 0 }), status: 200 });
-            const result = await cache.listLength('list');
-            expect(result).toBe(0);
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-        it('handles failure', async () => {
-            const { cache, fetch } = buildCache();
-            fetch.mockResolvedValueOnce({ ok: false, text: async () => 'Not allowed', status: 403 });
-            await expect(cache.listLength('list')).rejects.toMatchError(new cache_1.ApiError(403, 'UNKNOWN_ERROR', 'Not allowed'));
-            expect(fetch.mock.lastCall).toMatchSnapshot();
-        });
-    });
-});

package/out/__test__/tunnel.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tunnel.test.d.ts.map

package/out/__test__/tunnel.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tunnel.test.d.ts","sourceRoot":"","sources":["../../src/__test__/tunnel.test.ts"],"names":[],"mappings":""}

package/out/__test__/tunnel.test.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const tunnel_1 = require("../tunnel");
-const validator_1 = require("../utils/validator");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const tmp_1 = require("tmp");
-describe('Forge Cache Tunnel', () => {
-    let cache;
-    beforeEach(() => {
-        const fileName = (0, tmp_1.tmpNameSync)({ postfix: '.json' });
-        cache = new tunnel_1.TunnelCache(fileName);
-    });
-    test('set method', async () => {
-        const response = await cache.set('key', 'value');
-        expect(response).toStrictEqual(undefined);
-    });
-    test('get method', async () => {
-        await cache.set('key', 'value');
-        const response = await cache.get('key');
-        expect(response).toStrictEqual('value');
-    });
-    test('get method throws error for list value', async () => {
-        await cache.leftPush('key', 'value1');
-        try {
-            await cache.get('key');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('setIfNotExists method', async () => {
-        const response = await cache.setIfNotExists('key', 'value');
-        expect(response).toStrictEqual('OK');
-        const newResponse = await cache.setIfNotExists('key', 'new value');
-        expect(newResponse).toStrictEqual(null);
-    });
-    test('getAndSet method', async () => {
-        await cache.set('key', 'value');
-        const response = await cache.getAndSet('key', 'new value');
-        expect(response).toStrictEqual('value');
-        const newResponse = await cache.get('key');
-        expect(newResponse).toStrictEqual('new value');
-    });
-    test('delete method', async () => {
-        await cache.set('key', 'value');
-        const response = await cache.delete('key');
-        expect(response).toStrictEqual(1);
-        const newResponse = await cache.get('key');
-        expect(newResponse).toStrictEqual(null);
-    });
-    test('incrementAndGet method', async () => {
-        await cache.set('key', '5');
-        const response = await cache.incrementAndGet('key');
-        expect(response).toStrictEqual(6);
-    });
-    test('leftPush method', async () => {
-        await cache.leftPush('key', 'value1');
-        const response = await cache.leftPush('key', 'value2');
-        const result = ['value2', 'value1'].length;
-        expect(response).toStrictEqual(result);
-    });
-    test('rightPop method', async () => {
-        await cache.leftPush('key', 'value1');
-        await cache.leftPush('key', 'value2');
-        const response = await cache.rightPop('key');
-        expect(response).toStrictEqual('value1');
-    });
-    test('listLength method', async () => {
-        await cache.leftPush('key', 'value1');
-        await cache.leftPush('key', 'value2');
-        const response = await cache.listLength('key');
-        expect(response).toStrictEqual(2);
-    });
-    test('decrementAndGet method', async () => {
-        await cache.set('key', '5');
-        const response = await cache.decrementAndGet('key');
-        expect(response).toStrictEqual(4);
-    });
-    test('incrementAndGet method throws error when key holds a list value', async () => {
-        await cache.leftPush('key', 'value1');
-        try {
-            await cache.incrementAndGet('key');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('leftPush method throws error when key holds a non-list value', async () => {
-        await cache.set('key', 'value');
-        try {
-            await cache.leftPush('key', 'newValue');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('rightPop method throws error when key holds a non-list value', async () => {
-        await cache.set('key', 'value');
-        try {
-            await cache.rightPop('key');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('listLength method throws error when key holds a non-list value', async () => {
-        await cache.set('key', 'value');
-        try {
-            await cache.listLength('key');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('decrementAndGet method throws error when key holds a list value', async () => {
-        await cache.leftPush('key', 'value');
-        try {
-            await cache.decrementAndGet('key');
-        }
-        catch (error) {
-            expect(error).toEqual(new validator_1.WrongTypeOperationError());
-        }
-    });
-    test('scan method returns empty array when no matching keys', async () => {
-        await cache.set('key1', 'value1');
-        await cache.set('key2', 'value2');
-        await cache.set('key3', 'value3');
-        await cache.set('key4', 'value4');
-        await cache.set('key5', 'value5');
-        const scanResult = await cache.scan('nonexistent*');
-        expect(scanResult.keys).toEqual([]);
-    });
-    test('scan method returns keys starting with "key" prefix', async () => {
-        await cache.set('key1', 'value1');
-        await cache.set('key2', 'value2');
-        await cache.set('otherKey1', 'value3');
-        await cache.set('otherKey2', 'value4');
-        await cache.set('key3', 'value5');
-        const scanResult = await cache.scan('key*');
-        expect(scanResult.keys).toEqual(['key1', 'key2', 'key3']);
-    });
-    test('scan method returns keys with "2" in the middle', async () => {
-        await cache.set('key1', 'value1');
-        await cache.set('key2', 'value2');
-        await cache.set('otherKey1', 'value3');
-        await cache.set('otherKey2', 'value4');
-        await cache.set('key3', 'value5');
-        const scanResult = await cache.scan('*2*');
-        expect(scanResult.keys).toEqual(['key2', 'otherKey2']);
-    });
-    test('scan method returns keys with "l?st*" redis pattern', async () => {
-        await cache.set('list1', 'value1');
-        await cache.set('list2', 'value2');
-        await cache.set('list3', 'value3');
-        await cache.set('list4', 'value4');
-        await cache.set('lest5', 'value5');
-        await cache.set('key1', 'value1');
-        const scanResult = await cache.scan('l?st*');
-        expect(scanResult.keys).toEqual(['list1', 'list2', 'list3', 'list4', 'lest5']);
-    });
-});
-describe('Forge Cache Tunnel with json file', () => {
-    it('should save and load data from file', async () => {
-        const fileName = (0, tmp_1.tmpNameSync)({ postfix: '.json' });
-        const cache1 = new tunnel_1.TunnelCache(fileName);
-        await cache1.set('key', 'value');
-        await cache1.set('key2', 'value2');
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const savedFileContent = fs_1.default.readFileSync(fileName, `utf-8`);
-        expect(JSON.parse(savedFileContent)).toStrictEqual({ key: 'value', key2: 'value2' });
-        const cache2 = new tunnel_1.TunnelCache(fileName);
-        const res = await cache2.get('key');
-        expect(res).toBe('value');
-    });
-});