@libredb/studio 0.9.7

package/tests/components/studio/StudioMobileHeader.test.tsx

@@ -0,0 +1,198 @@
+import '../../setup-dom';
+import '../../helpers/mock-sonner';
+import '../../helpers/mock-navigation';
+
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test';
+import { cleanup, render, fireEvent } from '@testing-library/react';
+
+mock.module('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: ({ children }: { children: React.ReactNode }) => React.createElement('div', {}, children),
+  DropdownMenuTrigger: ({ children }: { children: React.ReactNode }) => React.createElement('div', {}, children),
+  DropdownMenuContent: ({ children }: { children: React.ReactNode }) => React.createElement('div', {}, children),
+  DropdownMenuItem: ({ children, onClick, disabled }: { children: React.ReactNode; onClick?: () => void; disabled?: boolean }) =>
+    React.createElement('div', { onClick: disabled ? undefined : onClick, role: 'menuitem', 'aria-disabled': disabled }, children),
+  DropdownMenuSeparator: ({ className }: { className?: string }) =>
+    React.createElement('hr', { className }),
+}));
+
+mock.module('@/components/ui/button', () => ({
+  Button: ({ children, onClick, className, disabled, ...rest }: Record<string, unknown>) =>
+    React.createElement('button', { onClick: onClick as (() => void), className, disabled, ...rest }, children as React.ReactNode),
+}));
+
+mock.module('lucide-react', () => {
+  return new Proxy({}, {
+    get: (_target, prop) => {
+      if (prop === '__esModule') return true;
+      return (props: Record<string, unknown>) =>
+        React.createElement('span', { 'data-icon': prop, className: props.className as string });
+    },
+  });
+});
+
+import { StudioMobileHeader } from '@/components/studio/StudioMobileHeader';
+import type { DatabaseConnection } from '@/lib/types';
+
+const conn: DatabaseConnection = { id: '1', name: 'prod-db', type: 'postgres', host: 'localhost', port: 5432, database: 'db', user: 'u', password: 'p', createdAt: new Date() };
+
+describe('StudioMobileHeader', () => {
+  afterEach(() => { cleanup(); });
+
+  const mockToggleAi = mock(() => {});
+  const mockOnExplain = mock(() => {});
+  const mockOnBeginTransaction = mock(() => {});
+  const mockOnCommitTransaction = mock(() => {});
+  const mockOnRollbackTransaction = mock(() => {});
+  const mockOnTogglePlayground = mock(() => {});
+  const mockOnToggleEditing = mock(() => {});
+  const mockOnImport = mock(() => {});
+
+  const defaults = {
+    connections: [conn],
+    activeConnection: conn,
+    connectionPulse: 'healthy' as const,
+    user: { role: 'admin' },
+    isAdmin: true,
+    activeMobileTab: 'editor' as const,
+    isExecuting: false,
+    currentQuery: 'SELECT 1',
+    queryEditorRef: { current: { toggleAi: mockToggleAi, format: mock(() => {}), getValue: mock(() => 'SELECT 1'), getSelectedText: mock(() => ''), getEffectiveQuery: mock(() => 'SELECT 1'), setValue: mock(() => {}), focus: mock(() => {}) } },
+    transactionActive: false,
+    playgroundMode: false,
+    editingEnabled: false,
+    onSelectConnection: mock(() => {}),
+    onAddConnection: mock(() => {}),
+    onLogout: mock(() => {}),
+    onSaveQuery: mock(() => {}),
+    onClearQuery: mock(() => {}),
+    onExecuteQuery: mock(() => {}),
+    onCancelQuery: mock(() => {}),
+    onBeginTransaction: mockOnBeginTransaction,
+    onCommitTransaction: mockOnCommitTransaction,
+    onRollbackTransaction: mockOnRollbackTransaction,
+    onTogglePlayground: mockOnTogglePlayground,
+    onToggleEditing: mockOnToggleEditing,
+    onImport: mockOnImport,
+  };
+
+  beforeEach(() => {
+    mockToggleAi.mockClear();
+    mockOnExplain.mockClear();
+    mockOnBeginTransaction.mockClear();
+    mockOnCommitTransaction.mockClear();
+    mockOnRollbackTransaction.mockClear();
+    mockOnTogglePlayground.mockClear();
+    mockOnToggleEditing.mockClear();
+    mockOnImport.mockClear();
+  });
+
+  test('renders DB selector and Online badge', () => {
+    const { queryAllByText, container } = render(<StudioMobileHeader {...defaults} />);
+    expect(queryAllByText('prod-db').length).toBeGreaterThan(0);
+    expect(container.textContent).toContain('Online');
+  });
+
+  test('shows RUN button when on editor tab', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    expect(queryByText('RUN')).not.toBeNull();
+  });
+
+  test('shows CANCEL button when executing', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} isExecuting />);
+    expect(queryByText('CANCEL')).not.toBeNull();
+  });
+
+  test('hides action row when not on editor tab', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} activeMobileTab="database" />);
+    expect(queryByText('RUN')).toBeNull();
+  });
+
+  test('shows Select DB when no active connection', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} activeConnection={null} />);
+    expect(queryByText('Select DB')).not.toBeNull();
+  });
+
+  // =========================================================================
+  // Callbacks & Badges
+  // =========================================================================
+
+  test('AI button click calls queryEditorRef.current.toggleAi()', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    const aiBtn = queryByText('AI');
+    expect(aiBtn).not.toBeNull();
+    fireEvent.click(aiBtn!.closest('button')!);
+    expect(mockToggleAi).toHaveBeenCalledTimes(1);
+  });
+
+  test('Explain Plan click calls onExplain when provided', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} onExplain={mockOnExplain} />);
+    const explainItem = queryByText('Explain Plan');
+    expect(explainItem).not.toBeNull();
+    fireEvent.click(explainItem!.closest('[role="menuitem"]')!);
+    expect(mockOnExplain).toHaveBeenCalledTimes(1);
+  });
+
+  test('Explain Plan not rendered when onExplain is undefined', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    expect(queryByText('Explain Plan')).toBeNull();
+  });
+
+  test('BEGIN Transaction click calls onBeginTransaction', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    const item = queryByText('BEGIN Transaction');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnBeginTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('transactionActive=true shows COMMIT and calls onCommitTransaction', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} transactionActive />);
+    const item = queryByText('COMMIT');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnCommitTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('transactionActive=true shows ROLLBACK and calls onRollbackTransaction', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} transactionActive />);
+    const item = queryByText('ROLLBACK');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnRollbackTransaction).toHaveBeenCalledTimes(1);
+  });
+
+  test('Enable Sandbox click calls onTogglePlayground', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    const item = queryByText('Enable Sandbox');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnTogglePlayground).toHaveBeenCalledTimes(1);
+  });
+
+  test('Enable Editing click calls onToggleEditing', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    const item = queryByText('Enable Editing');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnToggleEditing).toHaveBeenCalledTimes(1);
+  });
+
+  test('Import Data click calls onImport', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} />);
+    const item = queryByText('Import Data');
+    expect(item).not.toBeNull();
+    fireEvent.click(item!.closest('[role="menuitem"]')!);
+    expect(mockOnImport).toHaveBeenCalledTimes(1);
+  });
+
+  test('transactionActive=true shows TXN badge', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} transactionActive />);
+    expect(queryByText('TXN')).not.toBeNull();
+  });
+
+  test('playgroundMode=true shows SANDBOX badge', () => {
+    const { queryByText } = render(<StudioMobileHeader {...defaults} playgroundMode />);
+    expect(queryByText('SANDBOX')).not.toBeNull();
+  });
+});

package/tests/components/studio/StudioTabBar.test.tsx

@@ -0,0 +1,331 @@
+import '../../setup-dom';
+import '../../helpers/mock-sonner';
+import '../../helpers/mock-navigation';
+
+import { describe, test, expect, mock, afterEach } from 'bun:test';
+import { render, fireEvent, cleanup } from '@testing-library/react';
+import React from 'react';
+
+import { StudioTabBar } from '@/components/studio/StudioTabBar';
+import type { QueryTab } from '@/lib/types';
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+afterEach(() => {
+  cleanup();
+});
+
+function createTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: 'tab-1',
+    name: 'Query 1',
+    query: 'SELECT 1',
+    result: null,
+    isExecuting: false,
+    type: 'sql',
+    ...overrides,
+  };
+}
+
+function createDefaultProps(overrides: Record<string, unknown> = {}) {
+  const tab1 = createTab({ id: 'tab-1', name: 'Query 1' });
+  const tab2 = createTab({ id: 'tab-2', name: 'Query 2', type: 'mongodb' });
+
+  return {
+    tabs: [tab1, tab2],
+    activeTabId: 'tab-1',
+    editingTabId: null as string | null,
+    editingTabName: '',
+    onSetActiveTabId: mock(() => {}),
+    onSetEditingTabId: mock(() => {}),
+    onSetEditingTabName: mock(() => {}),
+    onSetTabs: mock(() => {}),
+    onCloseTab: mock(() => {}),
+    onAddTab: mock(() => {}),
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('StudioTabBar', () => {
+
+  // ── Basic rendering ─────────────────────────────────────────────────────
+
+  test('renders all tab names', () => {
+    const props = createDefaultProps();
+    const { queryByText } = render(<StudioTabBar {...props} />);
+    expect(queryByText('Query 1')).not.toBeNull();
+    expect(queryByText('Query 2')).not.toBeNull();
+  });
+
+  test('active tab has blue border and bg styling', () => {
+    const props = createDefaultProps({ activeTabId: 'tab-1' });
+    const { container } = render(<StudioTabBar {...props} />);
+    const tabElements = container.querySelectorAll('[class*="border-t-2"]');
+    expect(tabElements[0]?.className).toContain('border-blue-500');
+    expect(tabElements[0]?.className).toContain('bg-[#141414]');
+  });
+
+  test('inactive tab has transparent border', () => {
+    const props = createDefaultProps({ activeTabId: 'tab-1' });
+    const { container } = render(<StudioTabBar {...props} />);
+    const tabElements = container.querySelectorAll('[class*="border-t-2"]');
+    expect(tabElements[1]?.className).toContain('border-transparent');
+  });
+
+  // ── Tab type icons ────────────────────────────────────────────────────
+
+  test('renders different icons for sql and json tabs', () => {
+    const props = createDefaultProps();
+    const { container } = render(<StudioTabBar {...props} />);
+    // Each tab should have at least one icon SVG (w-3 h-3)
+    const tabElements = container.querySelectorAll('[class*="border-t-2"]');
+    expect(tabElements.length).toBe(2);
+    // Each tab div contains an SVG icon as the first child element
+    const tab1Svgs = tabElements[0]?.querySelectorAll('svg');
+    const tab2Svgs = tabElements[1]?.querySelectorAll('svg');
+    expect(tab1Svgs!.length).toBeGreaterThanOrEqual(1);
+    expect(tab2Svgs!.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ── Click → activate tab ──────────────────────────────────────────────
+
+  test('click on tab fires onSetActiveTabId with tab id', () => {
+    const onSetActiveTabId = mock(() => {});
+    const props = createDefaultProps({ onSetActiveTabId });
+    const { container } = render(<StudioTabBar {...props} />);
+    const tabElements = container.querySelectorAll('[class*="border-t-2"]');
+    fireEvent.click(tabElements[1]!);
+    expect(onSetActiveTabId).toHaveBeenCalledTimes(1);
+    expect(onSetActiveTabId).toHaveBeenCalledWith('tab-2');
+  });
+
+  // ── Plus button ───────────────────────────────────────────────────────
+
+  test('plus button fires onAddTab', () => {
+    const onAddTab = mock(() => {});
+    const props = createDefaultProps({ onAddTab });
+    const { container } = render(<StudioTabBar {...props} />);
+    const svgElements = container.querySelectorAll('svg');
+    const plusIcon = Array.from(svgElements).find(el =>
+      el.getAttribute('class')?.includes('cursor-pointer')
+    );
+    expect(plusIcon).not.toBeNull();
+    fireEvent.click(plusIcon!);
+    expect(onAddTab).toHaveBeenCalledTimes(1);
+  });
+
+  // ── Close button ──────────────────────────────────────────────────────
+
+  test('close button fires onCloseTab when multiple tabs', () => {
+    const onCloseTab = mock(() => {});
+    const props = createDefaultProps({ onCloseTab });
+    const { container } = render(<StudioTabBar {...props} />);
+    const closeIcons = container.querySelectorAll('svg[class*="ml-auto"]');
+    expect(closeIcons.length).toBeGreaterThan(0);
+    fireEvent.click(closeIcons[0]);
+    expect(onCloseTab).toHaveBeenCalledTimes(1);
+  });
+
+  test('close button hidden when only one tab', () => {
+    const singleTab = createTab({ id: 'tab-1', name: 'Query 1' });
+    const props = createDefaultProps({ tabs: [singleTab], activeTabId: 'tab-1' });
+    const { container } = render(<StudioTabBar {...props} />);
+    const closeIcons = container.querySelectorAll('svg[class*="ml-auto"]');
+    expect(closeIcons.length).toBe(0);
+  });
+
+  // ── Double-click → rename mode ────────────────────────────────────────
+
+  test('double-click on tab enters rename mode', () => {
+    const onSetEditingTabId = mock(() => {});
+    const onSetEditingTabName = mock(() => {});
+    const props = createDefaultProps({ onSetEditingTabId, onSetEditingTabName });
+    const { container } = render(<StudioTabBar {...props} />);
+    const tabElements = container.querySelectorAll('[class*="border-t-2"]');
+    fireEvent.doubleClick(tabElements[0]!);
+    expect(onSetEditingTabId).toHaveBeenCalledTimes(1);
+    expect(onSetEditingTabId).toHaveBeenCalledWith('tab-1');
+    expect(onSetEditingTabName).toHaveBeenCalledTimes(1);
+    expect(onSetEditingTabName).toHaveBeenCalledWith('Query 1');
+  });
+
+  // ── Rename input rendering ────────────────────────────────────────────
+
+  test('shows input field when editingTabId matches', () => {
+    const props = createDefaultProps({ editingTabId: 'tab-1', editingTabName: 'Query 1' });
+    const { container, queryByText } = render(<StudioTabBar {...props} />);
+    // Tab name text should not be visible as span (it's an input now)
+    const input = container.querySelector('input');
+    expect(input).not.toBeNull();
+    expect(input!.value).toBe('Query 1');
+    // The span for tab-1 should not exist when editing
+    // tab-2 name should still show as span
+    expect(queryByText('Query 2')).not.toBeNull();
+  });
+
+  // ── Rename input onChange ─────────────────────────────────────────────
+
+  test('rename input is rendered with correct value and className', () => {
+    const props = createDefaultProps({ editingTabId: 'tab-1', editingTabName: 'Query 1' });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    expect(input).not.toBeNull();
+    expect(input.value).toBe('Query 1');
+    expect(input.className).toContain('border-blue-500');
+    expect(input.className).toContain('bg-transparent');
+  });
+
+  // ── Rename commit via blur ────────────────────────────────────────────
+
+  test('blur on rename input commits name and exits editing', () => {
+    const onSetTabs = mock(() => {});
+    const onSetEditingTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: 'New Name',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.blur(input);
+    expect(onSetTabs).toHaveBeenCalledTimes(1);
+    expect(onSetEditingTabId).toHaveBeenCalledTimes(1);
+    expect(onSetEditingTabId).toHaveBeenCalledWith(null);
+  });
+
+  test('blur with empty name does not call onSetTabs', () => {
+    const onSetTabs = mock(() => {});
+    const onSetEditingTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: '   ',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.blur(input);
+    expect(onSetTabs).not.toHaveBeenCalled();
+    expect(onSetEditingTabId).toHaveBeenCalledWith(null);
+  });
+
+  // ── Rename commit via Enter ───────────────────────────────────────────
+
+  test('Enter key commits name and exits editing', () => {
+    const onSetTabs = mock(() => {});
+    const onSetEditingTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: 'Via Enter',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.keyDown(input, { key: 'Enter' });
+    expect(onSetTabs).toHaveBeenCalledTimes(1);
+    expect(onSetEditingTabId).toHaveBeenCalledWith(null);
+  });
+
+  test('Enter with empty name does not call onSetTabs', () => {
+    const onSetTabs = mock(() => {});
+    const onSetEditingTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: '',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.keyDown(input, { key: 'Enter' });
+    expect(onSetTabs).not.toHaveBeenCalled();
+    expect(onSetEditingTabId).toHaveBeenCalledWith(null);
+  });
+
+  // ── Rename cancel via Escape ──────────────────────────────────────────
+
+  test('Escape key cancels editing without saving', () => {
+    const onSetTabs = mock(() => {});
+    const onSetEditingTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: 'Unsaved',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.keyDown(input, { key: 'Escape' });
+    expect(onSetTabs).not.toHaveBeenCalled();
+    expect(onSetEditingTabId).toHaveBeenCalledWith(null);
+  });
+
+  // ── Input click does not bubble ───────────────────────────────────────
+
+  test('clicking rename input does not fire onSetActiveTabId', () => {
+    const onSetActiveTabId = mock(() => {});
+    const props = createDefaultProps({
+      editingTabId: 'tab-1',
+      editingTabName: 'Query 1',
+      onSetActiveTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.click(input);
+    expect(onSetActiveTabId).not.toHaveBeenCalled();
+  });
+
+  // ── onSetTabs updater function produces correct result ────────────────
+
+  test('onSetTabs updater renames the correct tab', () => {
+    let capturedFn: ((prev: QueryTab[]) => QueryTab[]) | null = null;
+    const onSetTabs = mock((fn: (prev: QueryTab[]) => QueryTab[]) => { capturedFn = fn; });
+    const onSetEditingTabId = mock(() => {});
+    const tab1 = createTab({ id: 'tab-1', name: 'Query 1' });
+    const tab2 = createTab({ id: 'tab-2', name: 'Query 2' });
+    const props = createDefaultProps({
+      tabs: [tab1, tab2],
+      editingTabId: 'tab-1',
+      editingTabName: 'Renamed',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.keyDown(input, { key: 'Enter' });
+
+    expect(capturedFn).not.toBeNull();
+    const result = capturedFn!([tab1, tab2]);
+    expect(result[0].name).toBe('Renamed');
+    expect(result[1].name).toBe('Query 2');
+  });
+
+  test('onSetTabs updater via blur renames correctly', () => {
+    let capturedFn: ((prev: QueryTab[]) => QueryTab[]) | null = null;
+    const onSetTabs = mock((fn: (prev: QueryTab[]) => QueryTab[]) => { capturedFn = fn; });
+    const onSetEditingTabId = mock(() => {});
+    const tab1 = createTab({ id: 'tab-1', name: 'Query 1' });
+    const props = createDefaultProps({
+      tabs: [tab1],
+      editingTabId: 'tab-1',
+      editingTabName: 'Blur Name',
+      onSetTabs,
+      onSetEditingTabId,
+    });
+    const { container } = render(<StudioTabBar {...props} />);
+    const input = container.querySelector('input')!;
+    fireEvent.blur(input);
+
+    expect(capturedFn).not.toBeNull();
+    const result = capturedFn!([tab1]);
+    expect(result[0].name).toBe('Blur Name');
+  });
+});

package/tests/fixtures/connections.ts

@@ -0,0 +1,96 @@
+import type { DatabaseConnection } from '@/lib/types';
+
+export const mockPostgresConnection: DatabaseConnection = {
+  id: 'test-pg-1',
+  name: 'Test PostgreSQL',
+  type: 'postgres',
+  host: 'localhost',
+  port: 5432,
+  user: 'testuser',
+  password: 'testpass',
+  database: 'testdb',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'development',
+};
+
+export const mockMySQLConnection: DatabaseConnection = {
+  id: 'test-mysql-1',
+  name: 'Test MySQL',
+  type: 'mysql',
+  host: 'localhost',
+  port: 3306,
+  user: 'testuser',
+  password: 'testpass',
+  database: 'testdb',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'development',
+};
+
+export const mockSQLiteConnection: DatabaseConnection = {
+  id: 'test-sqlite-1',
+  name: 'Test SQLite',
+  type: 'sqlite',
+  database: ':memory:',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'local',
+};
+
+export const mockMongoDBConnection: DatabaseConnection = {
+  id: 'test-mongo-1',
+  name: 'Test MongoDB',
+  type: 'mongodb',
+  host: 'localhost',
+  port: 27017,
+  database: 'testdb',
+  connectionString: 'mongodb://localhost:27017/testdb',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'development',
+};
+
+export const mockRedisConnection: DatabaseConnection = {
+  id: 'test-redis-1',
+  name: 'Test Redis',
+  type: 'redis',
+  host: 'localhost',
+  port: 6379,
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'development',
+};
+
+export const mockOracleConnection: DatabaseConnection = {
+  id: 'test-oracle-1',
+  name: 'Test Oracle',
+  type: 'oracle',
+  host: 'localhost',
+  port: 1521,
+  user: 'testuser',
+  password: 'testpass',
+  database: 'testdb',
+  serviceName: 'XEPDB1',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'staging',
+};
+
+export const mockMSSQLConnection: DatabaseConnection = {
+  id: 'test-mssql-1',
+  name: 'Test MSSQL',
+  type: 'mssql',
+  host: 'localhost',
+  port: 1433,
+  user: 'sa',
+  password: 'testpass',
+  database: 'testdb',
+  instanceName: 'SQLEXPRESS',
+  createdAt: new Date('2025-01-01T00:00:00Z'),
+  environment: 'staging',
+};
+
+export const allMockConnections: DatabaseConnection[] = [
+  mockPostgresConnection,
+  mockMySQLConnection,
+  mockSQLiteConnection,
+  mockMongoDBConnection,
+  mockRedisConnection,
+  mockOracleConnection,
+  mockMSSQLConnection,
+];