motia 0.13.2-beta.164-562802 → 0.13.2-beta.164-732151

package/dist/cjs/__tests__/openapi/generate.test.d.ts

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

package/dist/cjs/__tests__/openapi/generate.test.d.ts.map

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

package/dist/cjs/__tests__/openapi/generate.test.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const generate_1 = require("../../openapi/generate");
+jest.mock('fs', () => ({
+    readFileSync: jest.fn(),
+    writeFileSync: jest.fn(),
+}));
+describe('generateOpenApi', () => {
+    const mockProjectDir = '/mock/project';
+    const mockOutputFile = 'mock-project-openapi.json';
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fs.readFileSync.mockReturnValue(JSON.stringify({ name: 'test-project', version: '1.0.0' }));
+    });
+    const MOCK_API_STEP = {
+        filePath: '/mock/project/steps/test.ts',
+        version: '1.0.0',
+        config: {
+            type: 'api',
+            name: 'testApi',
+            path: '/test',
+            method: 'GET',
+            emits: [],
+        },
+    };
+    it('should generate a basic OpenAPI spec with default info', () => {
+        const apiSteps = [MOCK_API_STEP];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should handle bodySchema and responseSchema correctly', () => {
+        const mockBodySchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+            },
+        };
+        const mockResponseSchema = {
+            200: {
+                type: 'object',
+                properties: {
+                    message: { type: 'string' },
+                },
+            },
+        };
+        const mockApiStep = {
+            ...MOCK_API_STEP,
+            config: {
+                ...MOCK_API_STEP.config,
+                type: 'api',
+                name: 'testApiWithSchemas',
+                path: '/test-schemas',
+                method: 'POST',
+                bodySchema: mockBodySchema,
+                responseSchema: mockResponseSchema,
+                emits: [],
+            },
+        };
+        const apiSteps = [mockApiStep];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test-schemas': {
+                    post: {
+                        summary: 'testApiWithSchemas',
+                        description: undefined,
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: mockBodySchema,
+                                },
+                            },
+                        },
+                        responses: {
+                            200: {
+                                description: 'Response for status code 200',
+                                content: {
+                                    'application/json': {
+                                        schema: mockResponseSchema[200],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should use provided title', () => {
+        const apiSteps = [MOCK_API_STEP];
+        const customTitle = 'Custom API';
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, customTitle);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: customTitle,
+                version: '1.0.0',
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, 'openapi.json'), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should use provided version', () => {
+        const apiSteps = [MOCK_API_STEP];
+        const customVersion = '2.0.0';
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, customVersion, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: customVersion,
+            },
+            paths: {
+                '/test': {
+                    get: {
+                        summary: 'testApi',
+                        description: undefined,
+                        requestBody: undefined,
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+    it('should handle complex bodySchema with anyOf, nullable, and $ref', () => {
+        const mockUserSchema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                email: { type: 'string', format: 'email' },
+            },
+            required: ['name', 'email'],
+        };
+        const mockComplexBodySchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                status: {
+                    anyOf: [{ type: 'string', enum: ['active', 'inactive'] }, { type: 'number', enum: [0, 1] }, { type: 'null' }],
+                },
+                user: { $ref: '#/components/schemas/User' },
+            },
+            required: ['id'],
+            $defs: {
+                User: mockUserSchema,
+            },
+        };
+        const mockApiStep = {
+            ...MOCK_API_STEP,
+            filePath: '/mock/project/steps/complex.ts',
+            config: {
+                ...MOCK_API_STEP.config,
+                type: 'api',
+                name: 'testComplexApi',
+                path: '/test-complex',
+                method: 'PUT',
+                emits: [],
+                bodySchema: mockComplexBodySchema,
+            },
+        };
+        const apiSteps = [mockApiStep];
+        (0, generate_1.generateOpenApi)(mockProjectDir, apiSteps, undefined, undefined, mockOutputFile);
+        const expectedOpenApi = {
+            openapi: '3.0.0',
+            info: {
+                title: 'test-project',
+                version: '1.0.0',
+            },
+            paths: {
+                '/test-complex': {
+                    put: {
+                        summary: 'testComplexApi',
+                        description: undefined,
+                        requestBody: {
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            id: { type: 'string' },
+                                            status: {
+                                                anyOf: [
+                                                    { type: 'string', enum: ['active', 'inactive'] },
+                                                    { type: 'number', enum: [0, 1] },
+                                                ],
+                                                nullable: true,
+                                            },
+                                            user: { $ref: '#/components/schemas/User' },
+                                        },
+                                        required: ['id'],
+                                    },
+                                },
+                            },
+                        },
+                        responses: {},
+                    },
+                },
+            },
+            components: {
+                schemas: {
+                    User: mockUserSchema,
+                },
+            },
+        };
+        expect(fs.writeFileSync).toHaveBeenCalledWith(path.join(mockProjectDir, mockOutputFile), JSON.stringify(expectedOpenApi, null, 2));
+    });
+});

package/dist/cjs/__tests__/redis-memory-manager.test.d.ts

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

package/dist/cjs/__tests__/redis-memory-manager.test.d.ts.map

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

package/dist/cjs/__tests__/redis-memory-manager.test.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const redis_1 = require("redis");
+const redis_memory_server_1 = require("redis-memory-server");
+const redis_memory_manager_1 = require("../redis-memory-manager");
+jest.mock('fs');
+jest.mock('redis');
+jest.mock('redis-memory-server');
+const mockMkdirSync = fs_1.mkdirSync;
+const mockCreateClient = redis_1.createClient;
+const mockRedisMemoryServer = redis_memory_server_1.RedisMemoryServer;
+describe('redis-memory-manager', () => {
+    let mockRedisClient;
+    let mockServerInstance;
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+        mockRedisClient = {
+            connect: jest.fn().mockResolvedValue(undefined),
+            quit: jest.fn().mockResolvedValue(undefined),
+            isOpen: true,
+            on: jest.fn(),
+        };
+        mockServerInstance = {
+            getHost: jest.fn().mockResolvedValue('127.0.0.1'),
+            getPort: jest.fn().mockResolvedValue(6379),
+            stop: jest.fn().mockResolvedValue(undefined),
+        };
+        mockCreateClient.mockReturnValue(mockRedisClient);
+        mockRedisMemoryServer.mockImplementation(() => mockServerInstance);
+    });
+    afterEach(async () => {
+        await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+        process.env = originalEnv;
+    });
+    describe('instanceRedisMemoryServer', () => {
+        it('should start Redis server and return client', async () => {
+            const baseDir = '/test/dir';
+            const client = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockMkdirSync).toHaveBeenCalledWith(baseDir, { recursive: true });
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: {
+                    ip: '127.0.0.1',
+                    args: ['--appendonly', 'yes', '--save', '900 1', '--save', '300 10', '--save', '60 100', '--dir', baseDir],
+                },
+                autoStart: true,
+            });
+            expect(mockServerInstance.getHost).toHaveBeenCalled();
+            expect(mockServerInstance.getPort).toHaveBeenCalled();
+            expect(mockCreateClient).toHaveBeenCalledWith({
+                socket: {
+                    host: '127.0.0.1',
+                    port: 6379,
+                    reconnectStrategy: expect.any(Function),
+                    connectTimeout: 10000,
+                    keepAlive: true,
+                    noDelay: true,
+                },
+            });
+            expect(mockRedisClient.connect).toHaveBeenCalled();
+            expect(client).toBe(mockRedisClient);
+        });
+        it('should use custom host from environment variable', async () => {
+            process.env.MOTIA_REDIS_HOST = '192.168.1.1';
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, false);
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: expect.objectContaining({
+                    ip: '192.168.1.1',
+                }),
+                autoStart: false,
+            });
+        });
+        it('should use custom port from environment variable', async () => {
+            process.env.MOTIA_REDIS_PORT = '6380';
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockRedisMemoryServer).toHaveBeenCalledWith({
+                instance: expect.objectContaining({
+                    port: 6380,
+                }),
+                autoStart: true,
+            });
+        });
+        it('should return existing client if already running', async () => {
+            const baseDir = '/test/dir';
+            const client1 = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const client2 = await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, false);
+            expect(client1).toBe(client2);
+            expect(mockRedisMemoryServer).toHaveBeenCalledTimes(1);
+            expect(mockCreateClient).toHaveBeenCalledTimes(1);
+        });
+        it('should set up error handler on client', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            expect(mockRedisClient.on).toHaveBeenCalledWith('error', expect.any(Function));
+        });
+        it('should handle connection errors', async () => {
+            const baseDir = '/test/dir';
+            const error = new Error('Connection failed');
+            mockRedisClient.connect.mockRejectedValue(error);
+            await expect((0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true)).rejects.toThrow('Connection failed');
+        });
+        it('should handle server start errors', async () => {
+            const baseDir = '/test/dir';
+            const error = new Error('Server start failed');
+            mockServerInstance.getHost.mockRejectedValue(error);
+            await expect((0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true)).rejects.toThrow('Server start failed');
+        });
+        it('should implement reconnect strategy correctly', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const callArgs = mockCreateClient.mock.calls[0];
+            expect(callArgs).toBeDefined();
+            const socketConfig = callArgs?.[0]?.socket;
+            expect(socketConfig).toBeDefined();
+            const reconnectStrategy = socketConfig?.reconnectStrategy;
+            expect(reconnectStrategy).toBeDefined();
+            expect(typeof reconnectStrategy).toBe('function');
+            const mockError = new Error('test');
+            const strategyFn = reconnectStrategy;
+            expect(strategyFn(5, mockError)).toBe(500);
+            expect(strategyFn(10, mockError)).toBe(1000);
+            expect(strategyFn(11, mockError)).toBeInstanceOf(Error);
+            expect(strategyFn(11, mockError).message).toBe('Redis connection retry limit exceeded');
+            expect(strategyFn(15, mockError)).toBeInstanceOf(Error);
+            expect(strategyFn(20, mockError)).toBeInstanceOf(Error);
+            expect(strategyFn(30, mockError)).toBeInstanceOf(Error);
+            expect(strategyFn(50, mockError)).toBeInstanceOf(Error);
+        });
+    });
+    describe('stopRedisMemoryServer', () => {
+        it('should stop Redis server and close client', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should handle client close errors gracefully', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const error = new Error('Close failed');
+            mockRedisClient.quit.mockRejectedValue(error);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should handle server stop errors gracefully', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            const error = new Error('Stop failed');
+            mockServerInstance.stop.mockRejectedValue(error);
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).toHaveBeenCalled();
+            expect(mockServerInstance.stop).toHaveBeenCalled();
+        });
+        it('should not throw if client is not open', async () => {
+            const baseDir = '/test/dir';
+            await (0, redis_memory_manager_1.instanceRedisMemoryServer)(baseDir, true);
+            Object.defineProperty(mockRedisClient, 'isOpen', {
+                value: false,
+                writable: true,
+                configurable: true,
+            });
+            await expect((0, redis_memory_manager_1.stopRedisMemoryServer)()).resolves.not.toThrow();
+        });
+        it('should do nothing if server is not running', async () => {
+            await (0, redis_memory_manager_1.stopRedisMemoryServer)();
+            expect(mockRedisClient.quit).not.toHaveBeenCalled();
+            expect(mockServerInstance.stop).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/cjs/__tests__/test-helpers/redis-test-helper.d.ts

@@ -0,0 +1,52 @@
+export interface MockRedisClient {
+    connect: jest.Mock<Promise<void>>;
+    quit: jest.Mock<Promise<void>>;
+    disconnect: jest.Mock<Promise<void>>;
+    isOpen: boolean;
+    on: jest.Mock;
+    get: jest.Mock<Promise<string | null>>;
+    set: jest.Mock<Promise<string | null>>;
+    del: jest.Mock<Promise<number>>;
+    exists: jest.Mock<Promise<number>>;
+    keys: jest.Mock<Promise<string[]>>;
+    flushAll: jest.Mock<Promise<string>>;
+    ping: jest.Mock<Promise<string>>;
+    xAdd: jest.Mock<Promise<string>>;
+    xRead: jest.Mock<Promise<unknown[]>>;
+    xReadGroup: jest.Mock<Promise<unknown[]>>;
+    xGroupCreate: jest.Mock<Promise<string>>;
+    xAck: jest.Mock<Promise<number>>;
+    hGet: jest.Mock<Promise<string | null>>;
+    hSet: jest.Mock<Promise<number>>;
+    hGetAll: jest.Mock<Promise<Record<string, string>>>;
+    hDel: jest.Mock<Promise<number>>;
+    hExists: jest.Mock<Promise<number>>;
+    expire: jest.Mock<Promise<number>>;
+    ttl: jest.Mock<Promise<number>>;
+    publish: jest.Mock<Promise<number>>;
+    [key: string]: unknown;
+}
+export interface RedisTestHelperOptions {
+    autoConnect?: boolean;
+    isOpen?: boolean;
+}
+export declare function createMockRedisClient(options?: RedisTestHelperOptions): MockRedisClient;
+export declare function resetMockRedisClient(client: MockRedisClient): void;
+export declare function setupRedisTestHelper(): {
+    mockClient: MockRedisClient;
+    reset: () => void;
+};
+export declare class RedisTestHelper {
+    private client;
+    constructor(options?: RedisTestHelperOptions);
+    getClient(): MockRedisClient;
+    reset(): void;
+    mockGet(key: string, value: string | null): void;
+    mockSet(_key: string, _value: string): void;
+    mockExists(key: string, exists: boolean): void;
+    mockKeys(_pattern: string, keys: string[]): void;
+    mockConnectError(error: Error): void;
+    mockQuitError(error: Error): void;
+    setConnectionState(isOpen: boolean): void;
+}
+//# sourceMappingURL=redis-test-helper.d.ts.map

package/dist/cjs/__tests__/test-helpers/redis-test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-test-helper.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/test-helpers/redis-test-helper.ts"],"names":[],"mappings":"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"}

package/dist/cjs/__tests__/test-helpers/redis-test-helper.example.test.d.ts

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

package/dist/cjs/__tests__/test-helpers/redis-test-helper.example.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-test-helper.example.test.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/test-helpers/redis-test-helper.example.test.ts"],"names":[],"mappings":""}

package/dist/cjs/__tests__/test-helpers/redis-test-helper.example.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_test_helper_1 = require("./redis-test-helper");
+describe('RedisTestHelper Usage Examples', () => {
+    describe('using createMockRedisClient', () => {
+        it('should create a mock Redis client', async () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            expect(mockClient.isOpen).toBe(true);
+            expect(mockClient.connect).toBeDefined();
+            expect(mockClient.quit).toBeDefined();
+            await mockClient.connect();
+            expect(mockClient.connect).toHaveBeenCalledTimes(1);
+        });
+        it('should create a disconnected client', () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)({ isOpen: false });
+            expect(mockClient.isOpen).toBe(false);
+        });
+        it('should mock Redis operations', async () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            mockClient.get.mockResolvedValue('test-value');
+            mockClient.set.mockResolvedValue('OK');
+            const value = await mockClient.get('test-key');
+            expect(value).toBe('test-value');
+            const result = await mockClient.set('test-key', 'test-value');
+            expect(result).toBe('OK');
+        });
+    });
+    describe('using setupRedisTestHelper', () => {
+        it('should provide reset functionality', () => {
+            const { mockClient, reset } = (0, redis_test_helper_1.setupRedisTestHelper)();
+            mockClient.get('key1');
+            expect(mockClient.get).toHaveBeenCalledTimes(1);
+            reset();
+            expect(mockClient.get).toHaveBeenCalledTimes(0);
+        });
+    });
+    describe('using RedisTestHelper class', () => {
+        let helper;
+        beforeEach(() => {
+            helper = new redis_test_helper_1.RedisTestHelper();
+        });
+        afterEach(() => {
+            helper.reset();
+        });
+        it('should provide convenient mock methods', async () => {
+            const client = helper.getClient();
+            helper.mockGet('user:123', 'John Doe');
+            const value = await client.get('user:123');
+            expect(value).toBe('John Doe');
+            helper.mockExists('user:123', true);
+            const exists = await client.exists('user:123');
+            expect(exists).toBe(1);
+        });
+        it('should handle connection errors', async () => {
+            const error = new Error('Connection failed');
+            helper.mockConnectError(error);
+            const client = helper.getClient();
+            await expect(client.connect()).rejects.toThrow('Connection failed');
+        });
+        it('should allow changing connection state', () => {
+            const client = helper.getClient();
+            expect(client.isOpen).toBe(true);
+            helper.setConnectionState(false);
+            expect(client.isOpen).toBe(false);
+        });
+        it('should mock keys operation', async () => {
+            helper.mockKeys('user:*', ['user:1', 'user:2', 'user:3']);
+            const client = helper.getClient();
+            const keys = await client.keys('user:*');
+            expect(keys).toEqual(['user:1', 'user:2', 'user:3']);
+        });
+    });
+    describe('integration with RedisClientType', () => {
+        it('should have required Redis client methods', () => {
+            const mockClient = (0, redis_test_helper_1.createMockRedisClient)();
+            expect(mockClient.connect).toBeDefined();
+            expect(mockClient.quit).toBeDefined();
+            expect(mockClient.isOpen).toBeDefined();
+            expect(typeof mockClient.connect).toBe('function');
+            expect(typeof mockClient.quit).toBe('function');
+        });
+    });
+});