Testing

src/
├── test/
│   ├── App.critical.test.tsx    # Critical user paths
│   ├── App.user.test.tsx        # Common user scenarios
│   └── setup.ts                 # Test configuration
├── components/
│   └── ui/
│       └── Button.test.tsx      # Component tests
└── hooks/
    └── useRecording.test.ts     # Hook tests

import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import App from '../App';

test('user can start recording with hotkey', async () => {
  const user = userEvent.setup();
  render(<App />);
  
  // Simulate hotkey press
  await user.keyboard('{Meta>}r{/Meta}');
  
  // Verify recording started
  await waitFor(() => {
    expect(screen.getByText(/recording/i)).toBeInTheDocument();
  });
});

export default defineConfig({
  test: {
    globals: true,
    environment: 'jsdom',
    setupFiles: './src/test/setup.ts',
  },
});

src-tauri/src/
├── tests/
│   ├── audio_tests.rs
│   ├── whisper_tests.rs
│   ├── state_tests.rs
│   └── integration_tests.rs
├── audio/
│   └── recorder.rs              # Inline unit tests
└── whisper/
    └── engine.rs                # Inline unit tests

#[cfg(test)]
mod tests {
    use super::*;
    use tokio_test::*;

    #[tokio::test]
    async fn test_audio_recording() {
        let recorder = AudioRecorder::new();
        recorder.start().await.unwrap();
        
        tokio::time::sleep(Duration::from_secs(1)).await;
        
        let audio = recorder.stop().await.unwrap();
        assert!(audio.len() > 0);
    }

    #[test]
    fn test_sample_rate_conversion() {
        let input = vec![0.0; 16000];
        let output = convert_sample_rate(&input, 16000, 48000);
        assert_eq!(output.len(), 48000);
    }
}

[dev-dependencies]
tempfile = "3.10"
tokio-test = "0.4"
mockall = "0.12"
serial_test = "3.0"
rand = "0.8"

pnpm quality-gate

#!/bin/bash
set -e

echo "[1/4] Type checking..."
pnpm typecheck

echo "[2/4] Linting..."
pnpm lint

echo "[3/4] Frontend tests..."
pnpm test run

echo "[4/4] Backend tests..."
pnpm test:backend

echo "✓ All quality checks passed!"

pnpm test:coverage

cd src-tauri
cargo tarpaulin --out Html

cargo install cargo-tarpaulin

// ✅ Good - Test user behavior
test('user can download a model', async () => {
  render(<ModelsTab />);
  await user.click(screen.getByText(/download base/i));
  expect(await screen.findByText(/downloading/i)).toBeInTheDocument();
});

// ❌ Bad - Test implementation
test('downloadModel function is called', () => {
  const spy = vi.spyOn(api, 'downloadModel');
  // Testing internal implementation
});

import { waitFor } from '@testing-library/react';

test('transcription completes', async () => {
  render(<App />);
  
  // Trigger transcription
  await user.click(screen.getByRole('button', { name: /record/i }));
  
  // Wait for async completion
  await waitFor(() => {
    expect(screen.getByText(/transcription complete/i)).toBeInTheDocument();
  }, { timeout: 5000 });
});

#[tokio::test]
async fn test_model_download() {
    let downloader = ModelDownloader::new();
    let result = downloader.download("base").await;
    assert!(result.is_ok());
}

use mockall::predicate::*;
use mockall::mock;

mock! {
    pub WhisperEngine {}
    
    impl WhisperEngine {
        async fn transcribe(&self, audio: Vec<f32>) -> Result<String, Error>;
    }
}

#[tokio::test]
async fn test_transcription_flow() {
    let mut mock = MockWhisperEngine::new();
    mock.expect_transcribe()
        .returning(|_| Ok("Hello world".to_string()));
    
    let result = mock.transcribe(vec![]).await;
    assert_eq!(result.unwrap(), "Hello world");
}

use serial_test::serial;

#[test]
#[serial]
fn test_file_access() {
    // Tests that access shared resources
    // run serially to avoid conflicts
}

# .github/workflows/test.yml
name: Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [macos-latest, windows-latest]
    
    steps:
      - uses: actions/checkout@v3
      - name: Setup Node
        uses: actions/setup-node@v3
      - name: Setup Rust
        uses: actions-rs/toolchain@v1
      - name: Install dependencies
        run: pnpm install
      - name: Run quality gate
        run: pnpm quality-gate

pnpm benchmark

test('slow operation', async () => {
  // ...
}, { timeout: 10000 }); // 10 seconds

cd src-tauri
cargo build --tests

import { mockIPC } from '@tauri-apps/api/mocks';

mockIPC((cmd, args) => {
  if (cmd === 'start_recording') {
    return Promise.resolve();
  }
});