Initial push of Plunk Next

test/mocks/redis.mock.ts

@@ -0,0 +1,146 @@
+import { vi } from 'vitest';
+import { mockDeep, mockReset, type DeepMockProxy } from 'vitest-mock-extended';
+import type { Redis } from 'ioredis';
+
+/**
+ * Mock Redis instance for testing
+ * Uses in-memory Map to simulate Redis operations
+ */
+export class MockRedis {
+  private store = new Map<string, { value: string; expiry?: number }>();
+
+  get(key: string): Promise<string | null> {
+    const item = this.store.get(key);
+    if (!item) return Promise.resolve(null);
+
+    // Check expiry
+    if (item.expiry && Date.now() > item.expiry) {
+      this.store.delete(key);
+      return Promise.resolve(null);
+    }
+
+    return Promise.resolve(item.value);
+  }
+
+  set(key: string, value: string): Promise<'OK'> {
+    this.store.set(key, { value });
+    return Promise.resolve('OK');
+  }
+
+  setex(key: string, seconds: number, value: string): Promise<'OK'> {
+    const expiry = Date.now() + seconds * 1000;
+    this.store.set(key, { value, expiry });
+    return Promise.resolve('OK');
+  }
+
+  del(...keys: string[]): Promise<number> {
+    let count = 0;
+    for (const key of keys) {
+      if (this.store.delete(key)) count++;
+    }
+    return Promise.resolve(count);
+  }
+
+  incr(key: string): Promise<number> {
+    const item = this.store.get(key);
+    const current = item ? parseInt(item.value, 10) : 0;
+    const newValue = current + 1;
+    this.store.set(key, { value: String(newValue) });
+    return Promise.resolve(newValue);
+  }
+
+  expire(key: string, seconds: number): Promise<number> {
+    const item = this.store.get(key);
+    if (!item) return Promise.resolve(0);
+
+    const expiry = Date.now() + seconds * 1000;
+    this.store.set(key, { ...item, expiry });
+    return Promise.resolve(1);
+  }
+
+  exists(...keys: string[]): Promise<number> {
+    let count = 0;
+    for (const key of keys) {
+      if (this.store.has(key)) count++;
+    }
+    return Promise.resolve(count);
+  }
+
+  keys(pattern: string): Promise<string[]> {
+    const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+    const matchingKeys = Array.from(this.store.keys()).filter((key) => regex.test(key));
+    return Promise.resolve(matchingKeys);
+  }
+
+  flushall(): Promise<'OK'> {
+    this.store.clear();
+    return Promise.resolve('OK');
+  }
+
+  flushdb(): Promise<'OK'> {
+    this.store.clear();
+    return Promise.resolve('OK');
+  }
+
+  /**
+   * Clear all stored data (for test cleanup)
+   */
+  clear(): void {
+    this.store.clear();
+  }
+
+  /**
+   * Get all keys (for debugging)
+   */
+  getAllKeys(): string[] {
+    return Array.from(this.store.keys());
+  }
+
+  /**
+   * Get store size (for assertions)
+   */
+  size(): number {
+    return this.store.size;
+  }
+}
+
+/**
+ * Create a mock Redis instance using vitest-mock-extended
+ * This provides full type safety and spy functionality
+ */
+export function createMockRedis(): DeepMockProxy<Redis> {
+  const mock = mockDeep<Redis>();
+
+  // Default implementations
+  mock.get.mockResolvedValue(null);
+  mock.set.mockResolvedValue('OK');
+  mock.setex.mockResolvedValue('OK');
+  mock.del.mockResolvedValue(1);
+  mock.incr.mockResolvedValue(1);
+  mock.expire.mockResolvedValue(1);
+
+  return mock;
+}
+
+/**
+ * Create a functional mock Redis with in-memory storage
+ * Use this when you need Redis behavior (caching, expiry, etc.)
+ */
+export function createFunctionalMockRedis(): MockRedis {
+  return new MockRedis();
+}
+
+/**
+ * Reset a mock Redis instance
+ */
+export function resetMockRedis(redis: DeepMockProxy<Redis>): void {
+  mockReset(redis);
+
+  // Restore default implementations
+  redis.get.mockResolvedValue(null);
+  redis.set.mockResolvedValue('OK');
+  redis.setex.mockResolvedValue('OK');
+  redis.del.mockResolvedValue(1);
+  redis.incr.mockResolvedValue(1);
+  redis.expire.mockResolvedValue(1);
+}