@odvi/create-dtt-framework 0.1.3 → 0.1.6

package/template/src/test/mocks/supabase.ts

@@ -0,0 +1,37 @@
+import { vi } from 'vitest';
+
+// Mock Supabase client
+export const mockSupabaseClient = {
+  from: vi.fn(() => mockSupabaseClient),
+  select: vi.fn(() => mockSupabaseClient),
+  insert: vi.fn(() => mockSupabaseClient),
+  update: vi.fn(() => mockSupabaseClient),
+  delete: vi.fn(() => mockSupabaseClient),
+  eq: vi.fn(() => mockSupabaseClient),
+  order: vi.fn(() => mockSupabaseClient),
+  limit: vi.fn(() => mockSupabaseClient),
+  single: vi.fn(),
+  maybeSingle: vi.fn(),
+  rpc: vi.fn(),
+  auth: {
+    getUser: vi.fn(),
+    signInWithPassword: vi.fn(),
+    signOut: vi.fn(),
+    onAuthStateChange: vi.fn(),
+  },
+  storage: {
+    from: vi.fn(() => ({
+      upload: vi.fn(),
+      download: vi.fn(),
+      remove: vi.fn(),
+      list: vi.fn(),
+      getPublicUrl: vi.fn(),
+    })),
+  },
+};
+
+vi.mock('@supabase/supabase-js', () => ({
+  createClient: vi.fn(() => mockSupabaseClient),
+}));
+
+export default mockSupabaseClient;

package/template/src/test/setup.ts

@@ -0,0 +1,69 @@
+import '@testing-library/jest-dom';
+import { cleanup } from '@testing-library/react';
+import { afterEach, vi } from 'vitest';
+
+// Cleanup after each test
+afterEach(() => {
+  cleanup();
+});
+
+// Mock window.matchMedia
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});
+
+// Mock IntersectionObserver
+global.IntersectionObserver = class IntersectionObserver {
+  constructor() {}
+  disconnect() {}
+  observe() {}
+  takeRecords() {
+    return [];
+  }
+  unobserve() {}
+} as any;
+
+// Mock ResizeObserver
+global.ResizeObserver = class ResizeObserver {
+  constructor() {}
+  disconnect() {}
+  observe() {}
+  unobserve() {}
+} as any;
+
+// Mock requestAnimationFrame
+global.requestAnimationFrame = (callback: FrameRequestCallback) => {
+  return setTimeout(callback, 0) as unknown as number;
+};
+
+global.cancelAnimationFrame = (id: number) => {
+  clearTimeout(id);
+};
+
+// Suppress console errors in tests (optional, can be removed for debugging)
+const originalError = console.error;
+beforeAll(() => {
+  console.error = (...args: any[]) => {
+    if (
+      typeof args[0] === 'string' &&
+      args[0].includes('Warning: ReactDOM.render')
+    ) {
+      return;
+    }
+    originalError.call(console, ...args);
+  };
+});
+
+afterAll(() => {
+  console.error = originalError;
+});

package/template/src/test/utils/test-helpers.ts

@@ -0,0 +1,158 @@
+import type { RenderOptions } from '@testing-library/react';
+import { render } from '@testing-library/react';
+import type { ReactElement } from 'react';
+import { vi, beforeEach, afterEach } from 'vitest';
+
+/**
+ * Custom render function that includes providers if needed
+ */
+export function renderWithProviders(
+  ui: ReactElement,
+  options?: Omit<RenderOptions, 'wrapper'>
+) {
+  return render(ui, options);
+}
+
+/**
+ * Create a mock function that returns a resolved value
+ */
+export function mockResolved<T>(value: T) {
+  return vi.fn().mockResolvedValue(value);
+}
+
+/**
+ * Create a mock function that returns a rejected value
+ */
+export function mockRejected(error: Error | string) {
+  return vi.fn().mockRejectedValue(error instanceof Error ? error : new Error(error));
+}
+
+/**
+ * Wait for a specified amount of time
+ */
+export function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Create a mock user object
+ */
+export function createMockUser(overrides: Partial<any> = {}) {
+  return {
+    id: 'user-123',
+    email: 'test@example.com',
+    firstName: 'Test',
+    lastName: 'User',
+    imageUrl: 'https://example.com/avatar.jpg',
+    clerkOrgId: 'org-123',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock health check result
+ */
+export function createMockHealthCheck(overrides: Partial<any> = {}) {
+  return {
+    status: 'healthy',
+    responseTimeMs: 100,
+    message: 'Service is healthy',
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock service health object
+ */
+export function createMockServiceHealth(overrides: Partial<any> = {}) {
+  return {
+    name: 'Test Service',
+    icon: 'test-icon',
+    status: 'healthy',
+    responseTimeMs: 100,
+    checks: [
+      {
+        name: 'Test Check',
+        endpoint: '/test/endpoint',
+        status: 'healthy',
+        responseTimeMs: 50,
+      },
+    ],
+    ...overrides,
+  };
+}
+
+/**
+ * Mock console methods to suppress warnings in tests
+ */
+export function suppressConsoleWarnings() {
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  beforeEach(() => {
+    console.warn = vi.fn();
+    console.error = vi.fn();
+  });
+
+  afterEach(() => {
+    console.warn = originalWarn;
+    console.error = originalError;
+  });
+}
+
+/**
+ * Create a mock fetch response
+ */
+export function createMockResponse(
+  data: any,
+  status: number = 200,
+  ok: boolean = true
+) {
+  return {
+    ok,
+    status,
+    json: vi.fn().mockResolvedValue(data),
+    text: vi.fn().mockResolvedValue(JSON.stringify(data)),
+  };
+}
+
+/**
+ * Mock localStorage
+ */
+export function mockLocalStorage() {
+  const store: Record<string, string> = {};
+
+  return {
+    getItem: (key: string) => store[key] ?? null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      Object.keys(store).forEach((key) => delete store[key]);
+    },
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: (index: number) => Object.keys(store)[index] ?? null,
+  };
+}
+
+/**
+ * Create a mock router
+ */
+export function createMockRouter() {
+  return {
+    push: vi.fn(),
+    replace: vi.fn(),
+    prefetch: vi.fn(),
+    back: vi.fn(),
+    pathname: '/',
+    query: {},
+    asPath: '/',
+  };
+}

package/template/src/types/index.ts

@@ -0,0 +1,14 @@
+// Global type definitions placeholder
+
+export interface User {
+  id: string
+  email: string
+  firstName?: string
+  lastName?: string
+  imageUrl?: string
+  clerkOrgId?: string
+  createdAt: Date
+  updatedAt: Date
+}
+
+export type HealthStatus = 'healthy' | 'unhealthy' | 'error' | 'pending' | 'unconfigured'

package/template/tsconfig.json

@@ -0,0 +1,43 @@
+{
+  "compilerOptions": {
+    /* Base Options: */
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "target": "es2022",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+
+    /* Strictness */
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "checkJs": true,
+
+    /* Bundled projects */
+    "lib": ["dom", "dom.iterable", "ES2022"],
+    "noEmit": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "plugins": [{ "name": "next" }],
+    "incremental": true,
+
+    /* Path Aliases */
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"],
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.cjs",
+    "**/*.js",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": ["node_modules", "generated", "cli", "src/test", "**/*.test.ts", "**/*.test.tsx", "vitest.config.ts", "drizzle.config.ts", "supabase"]
+}

package/template/vitest.config.ts

@@ -0,0 +1,44 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.ts'],
+    include: ['**/__tests__/**/*.{test,spec}.{ts,tsx}', '**/*.{test,spec}.{ts,tsx}'],
+    exclude: ['node_modules', 'dist', '.next', 'coverage'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html', 'lcov'],
+      exclude: [
+        'node_modules/',
+        '.next/',
+        'dist/',
+        'coverage/',
+        '**/*.config.{js,ts}',
+        '**/types/**',
+        '**/test/**',
+        '**/__tests__/**',
+        '**/*.d.ts',
+        '**/mockData.ts',
+        'src/middleware.ts',
+        'src/env.js',
+      ],
+      all: true,
+      lines: 80,
+      functions: 80,
+      branches: 80,
+      statements: 80,
+    },
+    testTimeout: 10000,
+    hookTimeout: 10000,
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+});