@libredb/studio 0.9.7

package/tests/run-components.sh

@@ -0,0 +1,196 @@
+#!/bin/bash
+# Component test runner with mock isolation groups.
+#
+# bun's mock.module() is process-wide, so when one test file mocks a module,
+# every other file in the same bun process sees the mock instead of the real
+# module. This script groups test files so that no file runs in the same
+# process as a file that mocks its component module.
+#
+# Grouping rationale:
+#   Group 1 — Studio.test.tsx (mocks sidebar, schema-explorer, QueryEditor,
+#             studio/index, ConnectionModal, CommandPalette, SchemaDiagram,
+#             DataProfiler, CodeGenerator, TestDataGenerator, CreateTableModal,
+#             SaveQueryModal, etc.)
+#   Group 2 — Sidebar.test.tsx (mocks ConnectionsList, schema-explorer)
+#   Group 3 — BottomPanel.test.tsx (mocks ResultsGrid, QueryHistory,
+#             DataCharts, SchemaDiff, SavedQueries, VisualExplain, etc.)
+#   Group 4 — AdminDashboard.test.tsx (mocks OverviewTab, OperationsTab,
+#             MonitoringEmbed, SecurityTab, AuditTab)
+#   Group 5 — SecurityTab.test.tsx (mocks MaskingSettings)
+#   Group 6 — All remaining files (safe together — only mock libraries,
+#             ui primitives, or sub-components with no test files)
+
+set -e
+
+PASS=0
+FAIL=0
+TOTAL_GROUPS=18
+EXTRA_BUN_ARGS=("$@")
+GROUP_INDEX=0
+COVERAGE_MODE=0
+COVERAGE_BASE_DIR=""
+
+for arg in "${EXTRA_BUN_ARGS[@]}"; do
+  if [ "$arg" = "--coverage" ]; then
+    COVERAGE_MODE=1
+  fi
+  if [[ "$arg" == --coverage-dir=* ]]; then
+    COVERAGE_BASE_DIR="${arg#--coverage-dir=}"
+  fi
+done
+
+run_group() {
+  local label="$1"
+  shift
+  GROUP_INDEX=$((GROUP_INDEX + 1))
+  echo ""
+  echo "=== $label ==="
+
+  local RUN_ARGS=()
+  for arg in "${EXTRA_BUN_ARGS[@]}"; do
+    if [[ "$arg" == --coverage-dir=* ]]; then
+      continue
+    fi
+    RUN_ARGS+=("$arg")
+  done
+
+  if [ "$COVERAGE_MODE" -eq 1 ] && [ -n "$COVERAGE_BASE_DIR" ]; then
+    RUN_ARGS+=("--coverage-dir=${COVERAGE_BASE_DIR}/group-${GROUP_INDEX}")
+  fi
+
+  if bun test "${RUN_ARGS[@]}" "$@"; then
+    PASS=$((PASS + 1))
+  else
+    FAIL=$((FAIL + 1))
+    echo "FAILED: $label"
+  fi
+}
+
+# Group 0a: useStorageSync hook (isolated — mocks @/lib/storage which contaminates other hook tests)
+run_group "Group 0a: useStorageSync hook" \
+  tests/isolated/use-storage-sync.test.ts
+
+# Group 0b: Factory singleton (isolated — mocks provider modules which contaminates provider unit tests)
+run_group "Group 0b: Factory singleton" \
+  tests/isolated/factory-singleton.test.ts
+
+# Group 1: Studio (isolated — mocks almost every child component)
+run_group "Group 1/6: Studio" \
+  tests/components/Studio.test.tsx
+
+# Group 2: Sidebar (isolated — mocks ConnectionsList, SchemaExplorer)
+run_group "Group 2/6: Sidebar" \
+  tests/components/sidebar/Sidebar.test.tsx
+
+# Group 3: BottomPanel (isolated — mocks ResultsGrid, QueryHistory, DataCharts, SchemaDiff)
+run_group "Group 3/6: BottomPanel" \
+  tests/components/studio/BottomPanel.test.tsx
+
+# Group 4: AdminDashboard (isolated — mocks OverviewTab, OperationsTab, SecurityTab, AuditTab)
+run_group "Group 4/6: AdminDashboard" \
+  tests/components/admin/AdminDashboard.test.tsx
+
+# Group 5: SecurityTab (isolated — mocks MaskingSettings)
+run_group "Group 5/6: SecurityTab" \
+  tests/components/admin/SecurityTab.test.tsx
+
+# Group 6: MonitoringDashboard (isolated - mocks all monitoring tabs)
+run_group "Group 6/7: MonitoringDashboard" \
+  tests/components/monitoring/MonitoringDashboard.test.tsx
+
+# Group 7: Results-grid subcomponents (isolated from ResultsGrid.test.tsx mocks)
+run_group "Group 7/10: Results-grid subcomponents" \
+  tests/components/results-grid/StatsBar.test.tsx \
+  tests/components/results-grid/ResultCard.test.tsx \
+  tests/components/results-grid/RowDetailSheet.test.tsx
+
+# Group 8: SavedQueries (isolated - mocks @/lib/storage)
+run_group "Group 8/10: SavedQueries" \
+  tests/components/SavedQueries.test.tsx
+
+# Group 9: StudioHeaders + TableItem (isolated - mock dropdown-menu)
+run_group "Group 9/12: StudioHeaders & TableItem" \
+  tests/components/studio/StudioMobileHeader.test.tsx \
+  tests/components/studio/StudioDesktopHeader.test.tsx \
+  tests/components/schema-explorer/TableItem.test.tsx
+
+# Group 10: PoolTab (isolated - mock globalThis.fetch)
+run_group "Group 10/12: PoolTab" \
+  tests/components/monitoring/PoolTab.test.tsx
+
+# Group 11: Smoke tests (isolated - mock globalThis.fetch + MonitoringEmbed)
+run_group "Group 11/12: Smoke tests" \
+  tests/components/admin/MonitoringEmbed.test.tsx \
+  tests/components/VisualExplain.test.tsx \
+  tests/components/AIAutopilotPanel.test.tsx \
+  tests/components/DatabaseDocs.test.tsx \
+  tests/components/SnapshotTimeline.test.tsx \
+  tests/components/PivotTable.test.tsx \
+  tests/components/NL2SQLPanel.test.tsx \
+  tests/components/CodeGenerator.test.tsx \
+  tests/components/TestDataGenerator.test.tsx \
+  tests/components/CreateTableModal.test.tsx \
+  tests/components/SaveQueryModal.test.tsx \
+  tests/components/MobileNav.test.tsx \
+  tests/components/DataImportModal.test.tsx \
+  tests/components/RootLayout.test.tsx \
+  tests/components/Page.test.tsx \
+  tests/components/LoginPage.test.tsx \
+  tests/components/CommunitySection.test.tsx \
+  tests/components/AdminPage.test.tsx \
+  tests/components/MonitoringPage.test.tsx \
+  tests/components/monitoring/MetricChart.test.tsx
+
+# Group 12: MaskingSettings (isolated — mocks @/lib/data-masking with different shape than ResultsGrid/DataProfiler)
+run_group "Group 12/13: MaskingSettings" \
+  tests/components/MaskingSettings.test.tsx
+
+# Group 13: SchemaDiff (isolated — mocks @/components/ui/badge, @/components/ui/select)
+run_group "Group 13/14: SchemaDiff" \
+  tests/components/SchemaDiff.test.tsx
+
+# Group 16: ConnectionModal Mobile Drawer (isolated - useIsMobile returns true)
+run_group "Group 16/16: ConnectionModal Mobile" \
+  tests/components/ConnectionModal.mobile.test.tsx
+
+# Group 14: DataCharts (isolated — mocks @/lib/storage with chart methods)
+run_group "Group 14/16: DataCharts" \
+  tests/components/DataCharts.test.tsx
+
+# Group 15: All remaining files (safe together)
+run_group "Group 15/16: Remaining components" \
+  tests/components/QueryEditor.test.tsx \
+  tests/components/QuerySafetyDialog.test.tsx \
+  tests/components/QueryHistory.test.tsx \
+  tests/components/ConnectionModal.test.tsx \
+  tests/components/CommandPalette.test.tsx \
+  tests/components/ResultsGrid.test.tsx \
+  tests/components/SchemaDiagram.test.tsx \
+  tests/components/DataProfiler.test.tsx \
+  tests/components/schema-explorer/SchemaExplorer.test.tsx \
+  tests/components/sidebar/ConnectionItem.test.tsx \
+  tests/components/sidebar/ConnectionsList.test.tsx \
+  tests/components/studio/QueryToolbar.test.tsx \
+  tests/components/studio/StudioTabBar.test.tsx \
+  tests/components/admin/OverviewTab.test.tsx \
+  tests/components/admin/OperationsTab.test.tsx \
+  tests/components/admin/AuditTab.test.tsx \
+  tests/components/monitoring/StorageTab.test.tsx \
+  tests/components/monitoring/SessionsTab.test.tsx \
+  tests/components/monitoring/TablesTab.test.tsx \
+  tests/components/monitoring/QueriesTab.test.tsx \
+  tests/components/monitoring/PerformanceTab.test.tsx \
+  tests/components/monitoring/OverviewTab.test.tsx
+
+# Summary
+echo ""
+echo "========================================"
+if [ $FAIL -eq 0 ]; then
+  echo "All $TOTAL_GROUPS groups passed!"
+  if [ "$COVERAGE_MODE" -eq 1 ] && [ -n "$COVERAGE_BASE_DIR" ]; then
+    node scripts/merge-lcov.mjs "${COVERAGE_BASE_DIR}"/group-*/lcov.info "${COVERAGE_BASE_DIR}/lcov.info"
+  fi
+else
+  echo "$FAIL/$TOTAL_GROUPS groups FAILED"
+  exit 1
+fi

package/tests/setup-dom.ts

@@ -0,0 +1,58 @@
+/**
+ * DOM environment setup for hook and component tests.
+ * Uses happy-dom to provide document, window, and other browser globals.
+ * Import this at the top of test files that need a DOM environment.
+ */
+import { GlobalWindow } from 'happy-dom';
+
+if (typeof globalThis.document === 'undefined') {
+  const window = new GlobalWindow({ url: 'http://localhost:3000' });
+
+  // Copy essential DOM globals to globalThis
+  const domGlobals = [
+    'document', 'HTMLElement', 'HTMLInputElement', 'HTMLTextAreaElement',
+    'HTMLSelectElement', 'HTMLButtonElement', 'HTMLFormElement',
+    'HTMLDivElement', 'HTMLSpanElement', 'HTMLAnchorElement',
+    'Element', 'Node', 'Event', 'CustomEvent', 'MouseEvent', 'KeyboardEvent',
+    'MutationObserver', 'IntersectionObserver', 'ResizeObserver',
+    'navigator', 'location', 'history', 'getComputedStyle',
+    'requestAnimationFrame', 'cancelAnimationFrame',
+    'setTimeout', 'clearTimeout', 'setInterval', 'clearInterval',
+    'DOMParser', 'XMLSerializer', 'URL', 'URLSearchParams',
+    'AbortController', 'AbortSignal', 'Headers', 'Request', 'Response',
+    'FormData', 'Blob', 'File', 'FileReader', 'FileList',
+    'MediaQueryList', 'matchMedia',
+    'SVGElement', 'SVGSVGElement',
+    'Text', 'Comment', 'DocumentFragment',
+    'NodeList', 'HTMLCollection',
+    'NodeFilter', 'TreeWalker', 'Range', 'Selection',
+    'HTMLTableElement', 'HTMLTableRowElement', 'HTMLTableCellElement',
+    'HTMLLabelElement', 'HTMLImageElement', 'HTMLCanvasElement',
+    'HTMLPreElement', 'CSSStyleDeclaration',
+  ];
+
+  for (const key of domGlobals) {
+    if (key in window && !(key in globalThis)) {
+      try {
+        Object.defineProperty(globalThis, key, {
+          value: (window as unknown as Record<string, unknown>)[key],
+          writable: true,
+          configurable: true,
+        });
+      } catch {
+        // Some properties may not be transferable
+      }
+    }
+  }
+
+  // Ensure window itself is available
+  if (typeof globalThis.window === 'undefined') {
+    Object.defineProperty(globalThis, 'window', {
+      value: window,
+      writable: true,
+      configurable: true,
+    });
+  }
+}
+
+export {};

package/tests/setup.ts

@@ -0,0 +1,40 @@
+/**
+ * Global test setup — preloaded before every test file via bunfig.toml
+ */
+import { afterEach } from 'bun:test';
+
+// ─── Environment Variables ──────────────────────────────────────────────────
+process.env.JWT_SECRET = 'test-jwt-secret-for-unit-tests-32ch';
+process.env.ADMIN_EMAIL = 'admin@libredb.org';
+process.env.ADMIN_PASSWORD = 'LibreDB.2026';
+process.env.USER_EMAIL = 'user@libredb.org';
+process.env.USER_PASSWORD = 'LibreDB.2026';
+process.env.NEXT_PUBLIC_AUTH_PROVIDER = 'local';
+(process.env as Record<string, string>).NODE_ENV = 'test';
+
+// ─── In-memory localStorage mock (SSR/test environment) ────────────────────
+if (typeof globalThis.localStorage === 'undefined') {
+  const store = new Map<string, string>();
+  const localStorageMock: Storage = {
+    getItem: (key: string) => store.get(key) ?? null,
+    setItem: (key: string, value: string) => { store.set(key, String(value)); },
+    removeItem: (key: string) => { store.delete(key); },
+    clear: () => { store.clear(); },
+    get length() { return store.size; },
+    key: (index: number) => {
+      const keys = Array.from(store.keys());
+      return keys[index] ?? null;
+    },
+  };
+  Object.defineProperty(globalThis, 'localStorage', { value: localStorageMock, writable: true });
+}
+
+// ─── window mock (many source files check typeof window) ────────────────────
+if (typeof globalThis.window === 'undefined') {
+  Object.defineProperty(globalThis, 'window', { value: globalThis, writable: true });
+}
+
+// ─── Cleanup between tests ─────────────────────────────────────────────────
+afterEach(() => {
+  globalThis.localStorage.clear();
+});

package/tests/unit/api-errors.test.ts

@@ -0,0 +1,210 @@
+import '../setup';
+import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test';
+import type { Mock } from 'bun:test';
+import { createErrorResponse } from '@/lib/api/errors';
+import {
+  DatabaseError,
+  DatabaseConfigError,
+  ConnectionError,
+  AuthenticationError,
+  PoolExhaustedError,
+  QueryError,
+  QueryCancelledError,
+  TimeoutError,
+} from '@/lib/db/errors';
+import {
+  LLMError,
+  LLMAuthError,
+  LLMConfigError,
+  LLMRateLimitError,
+  LLMSafetyError,
+  LLMStreamError,
+} from '@/lib/llm/types';
+
+describe('createErrorResponse', () => {
+  // Suppress logger output during tests
+  let debugSpy: Mock<typeof console.debug>;
+  let infoSpy: Mock<typeof console.info>;
+  let warnSpy: Mock<typeof console.warn>;
+  let errorSpy: Mock<typeof console.error>;
+
+  beforeEach(() => {
+    debugSpy = spyOn(console, 'debug').mockImplementation(() => {});
+    infoSpy = spyOn(console, 'info').mockImplementation(() => {});
+    warnSpy = spyOn(console, 'warn').mockImplementation(() => {});
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    debugSpy.mockRestore();
+    infoSpy.mockRestore();
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  // ─── Database Errors ──────────────────────────────────────────────────────
+
+  test('QueryError returns 400 with code QUERY_ERROR', async () => {
+    const err = new QueryError('syntax error at position 5', 'postgres', 'SELECT *');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.code).toBe('QUERY_ERROR');
+    expect(body.statusCode).toBe(400);
+    expect(body.error).toContain('syntax error');
+  });
+
+  test('DatabaseConfigError returns 400 with code CONFIG_ERROR', async () => {
+    const err = new DatabaseConfigError('missing host', 'mysql');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.code).toBe('CONFIG_ERROR');
+    expect(body.statusCode).toBe(400);
+  });
+
+  test('AuthenticationError returns 401 with code AUTH_ERROR', async () => {
+    const err = new AuthenticationError('bad password', 'postgres');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(401);
+    const body = await res.json();
+    expect(body.code).toBe('AUTH_ERROR');
+    expect(body.statusCode).toBe(401);
+  });
+
+  test('TimeoutError returns 408 with code TIMEOUT_ERROR', async () => {
+    const err = new TimeoutError('query took too long', 'postgres', 30000);
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(408);
+    const body = await res.json();
+    expect(body.code).toBe('TIMEOUT_ERROR');
+    expect(body.statusCode).toBe(408);
+    expect(body.retryable).toBe(true);
+  });
+
+  test('ConnectionError returns 503 with code CONNECTION_ERROR', async () => {
+    const err = new ConnectionError('ECONNREFUSED', 'postgres', 'localhost', 5432);
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(503);
+    const body = await res.json();
+    expect(body.code).toBe('CONNECTION_ERROR');
+    expect(body.statusCode).toBe(503);
+    expect(body.retryable).toBe(true);
+  });
+
+  test('PoolExhaustedError returns 503 with code POOL_EXHAUSTED', async () => {
+    const err = new PoolExhaustedError('no connections available', 'postgres', 10);
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(503);
+    const body = await res.json();
+    expect(body.code).toBe('POOL_EXHAUSTED');
+    expect(body.statusCode).toBe(503);
+    expect(body.retryable).toBe(true);
+  });
+
+  test('DatabaseError (base) returns 500', async () => {
+    const err = new DatabaseError('unknown db error', 'postgres');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.statusCode).toBe(500);
+    expect(body.error).toContain('unknown db error');
+  });
+
+  test('QueryCancelledError returns 499 with code QUERY_CANCELLED', async () => {
+    const err = new QueryCancelledError('Query was cancelled', 'postgres', 'SELECT 1');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(499);
+    const body = await res.json();
+    expect(body.code).toBe('QUERY_CANCELLED');
+    expect(body.statusCode).toBe(499);
+  });
+
+  // ─── LLM Errors ──────────────────────────────────────────────────────────
+
+  test('LLMSafetyError returns 400 with code LLM_SAFETY', async () => {
+    const err = new LLMSafetyError('content blocked', 'gemini');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_SAFETY');
+    expect(body.statusCode).toBe(400);
+  });
+
+  test('LLMAuthError returns 401 with code LLM_AUTH', async () => {
+    const err = new LLMAuthError('invalid key', 'openai');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(401);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_AUTH');
+    expect(body.statusCode).toBe(401);
+  });
+
+  test('LLMRateLimitError returns 429 with code LLM_RATE_LIMIT', async () => {
+    const err = new LLMRateLimitError('quota exceeded', 'gemini');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(429);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_RATE_LIMIT');
+    expect(body.statusCode).toBe(429);
+    expect(body.retryable).toBe(true);
+  });
+
+  test('LLMConfigError returns 503 with code LLM_CONFIG', async () => {
+    const err = new LLMConfigError('missing API key', 'ollama');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(503);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_CONFIG');
+    expect(body.statusCode).toBe(503);
+  });
+
+  test('LLMStreamError returns 502 with code LLM_STREAM', async () => {
+    const err = new LLMStreamError('stream interrupted', 'openai');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(502);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_STREAM');
+    expect(body.statusCode).toBe(502);
+    expect(body.retryable).toBe(true);
+  });
+
+  test('LLMError (base) uses statusCode or 500', async () => {
+    const err = new LLMError('generic llm error', 'gemini', 503);
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(503);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_ERROR');
+    expect(body.statusCode).toBe(503);
+  });
+
+  test('LLMError (base) without statusCode defaults to 500', async () => {
+    const err = new LLMError('generic llm error', 'gemini');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.code).toBe('LLM_ERROR');
+    expect(body.statusCode).toBe(500);
+  });
+
+  // ─── Generic Errors ───────────────────────────────────────────────────────
+
+  test('generic Error returns 500 with code INTERNAL_ERROR', async () => {
+    const err = new Error('unexpected failure');
+    const res = createErrorResponse(err);
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.code).toBe('INTERNAL_ERROR');
+    expect(body.statusCode).toBe(500);
+    expect(body.error).toBe('unexpected failure');
+  });
+
+  test('non-Error (string) returns 500 with code INTERNAL_ERROR', async () => {
+    const res = createErrorResponse('something went wrong');
+    expect(res.status).toBe(500);
+    const body = await res.json();
+    expect(body.code).toBe('INTERNAL_ERROR');
+    expect(body.statusCode).toBe(500);
+    expect(body.error).toBe('Internal server error');
+  });
+});