test.yml

name: Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: ["**"]

permissions:
  contents: read
  pull-requests: read

concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: true

jobs:
  # Detect changes for conditional testing
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      frontend: ${{ steps.filter.outputs.frontend }}
      rust: ${{ steps.filter.outputs.rust }}
      rust-performance: ${{ steps.filter.outputs['rust-performance'] }}
      wasm: ${{ steps.filter.outputs.wasm }}
      integration: ${{ steps.filter.outputs.integration }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: filter
        with:
          list-files: shell
          filters: |
            frontend:
              - 'src/ts/**'
              - 'src/md-preview/**'
              - 'src/types/**'
              - 'test/ts/**'
              - 'package*.json'
              - 'tsconfig*.json'
              - 'vite*.config.*'
              - 'jest.config.*'
            rust:
              - 'src/rs/**'
              - 'test/rust/**'
              - 'Cargo.toml'
              - 'Cargo.lock'
              - 'build.rs'
              - 'signals.yaml'
            rust-performance:
              - 'test/rust/performance_tests.rs'
              - 'src/rs/fft/**'
              - 'src/rs/simd/**'
              - 'src/rs/sdr/processor/**'
              - 'Cargo.toml'
              - 'Cargo.lock'
            wasm:
              - 'src/rs/lib.rs'
              - 'src/rs/wasm/**'
              - 'src/rs/simd/**'
              - 'test/wasm/**'
              - 'Cargo-wasm.toml'
              - 'scripts/build/build_wasm.sh'
              - 'Cargo.lock'
              - 'package-lock.json'
            integration:
              - 'test/integration/**'
              - 'src/ts/crypto/**'
              - 'src/ts/services/**'
              - 'src/ts/workers/**'
              - 'src/rs/crypto/**'
              - 'src/rs/server/**'
              - 'src/rs/sdr/**'
              - 'scripts/**'
              - 'signals.yaml'
              - 'Cargo.toml'
              - 'Cargo.lock'

      - name: Print matched files
        run: |
          echo "frontend=${{ steps.filter.outputs.frontend }}"
          echo "${{ steps.filter.outputs.frontend_files }}"
          echo "rust=${{ steps.filter.outputs.rust }}"
          echo "${{ steps.filter.outputs.rust_files }}"
          echo "rust-performance=${{ steps.filter.outputs['rust-performance'] }}"
          echo "${{ steps.filter.outputs['rust-performance_files'] }}"
          echo "wasm=${{ steps.filter.outputs.wasm }}"
          echo "${{ steps.filter.outputs.wasm_files }}"
          echo "integration=${{ steps.filter.outputs.integration }}"
          echo "${{ steps.filter.outputs.integration_files }}"

  # Frontend type checking
  frontend-typecheck:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs.frontend == 'true'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js 26.x
        uses: actions/setup-node@v4
        with:
          node-version: 26.x
          cache: "npm"

      - name: Install dependencies
        run: npm ci --legacy-peer-deps

      - name: Run linting
        run: npm run lint

      - name: Run type checking
        run: npm run typecheck

  # Frontend tests
  frontend-tests:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs.frontend == 'true'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js 26.x
        uses: actions/setup-node@v4
        with:
          node-version: 26.x
          cache: "npm"

      - name: Install dependencies
        run: npm ci --legacy-peer-deps

      - name: Run tests (Affected Only on Branches)
        run: |
          if [ "${{ github.event_name }}" = "pull_request" ]; then
            changed_since="origin/${{ github.base_ref }}"
          else
            changed_since="${{ github.event.before }}"
          fi

          if [ -z "$changed_since" ] || [ "$changed_since" = "0000000000000000000000000000000000000000" ]; then
            npm test
            exit 0
          fi

          ./node_modules/.bin/jest test/ts --changedSince="$changed_since" --passWithNoTests

      - name: Upload coverage reports
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage/lcov.info
          flags: frontend
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: false

  # Rust tests
  rust-tests:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs.rust == 'true'

    services:
      redis:
        image: redis
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install system dependencies
        run: sudo apt-get update && sudo apt-get install -y librtlsdr-dev redis-server

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Install cargo-nextest
        run: cargo install cargo-nextest --locked

      - name: Cache Rust dependencies
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: .
          cache-on-failure: true

      - name: Run Rust tests
        run: |
          all_tests=(
            authentication_tests
            capture_stitch_tests
            device_stream_frozen_tests
            encryption_e2e_tests
            fft_processor_tests
            frequency_scaling_e2e
            frequency_validation_tests
            iq_capture_integration_tests
            mock_apt_tests
            server_tests
          )

          run_selected_tests() {
            for test_name in "$@"; do
              cargo nextest run --test "$test_name"
            done
          }

          if [ "${{ github.event_name }}" = "pull_request" ]; then
            git fetch --no-tags --prune --depth=1 origin "${{ github.base_ref }}"
            changed_since="origin/${{ github.base_ref }}"
          else
            changed_since="${{ github.event.before }}"
          fi

          if [ -z "$changed_since" ] || [ "$changed_since" = "0000000000000000000000000000000000000000" ]; then
            run_selected_tests "${all_tests[@]}"
            exit 0
          fi

          changed_files=$(git diff --name-only "$changed_since...HEAD" -- 'src/rs/**' 'test/rust/**' 'Cargo.toml' 'Cargo.lock' 'build.rs' 'signals.yaml')
          echo "Changed Rust files:"
          echo "$changed_files"

          tests=()
          run_all=false

          while IFS= read -r file; do
            case "$file" in
              Cargo.toml|Cargo.lock|build.rs|signals.yaml|src/rs/lib.rs)
                run_all=true
                ;;
              test/rust/performance_tests.rs)
                ;;
              test/rust/*.rs)
                test_name=$(basename "$file" .rs)
                tests+=("$test_name")
                ;;
              src/rs/authentication/*|src/rs/session/*)
                tests+=("authentication_tests" "server_tests")
                ;;
              src/rs/crypto/*)
                tests+=("encryption_e2e_tests" "authentication_tests")
                ;;
              src/rs/server/*)
                tests+=("server_tests" "device_stream_frozen_tests")
                ;;
              src/rs/sdr/mock_apt/*)
                tests+=("mock_apt_tests")
                ;;
              src/rs/sdr/processor/*)
                tests+=("capture_stitch_tests" "frequency_validation_tests" "iq_capture_integration_tests")
                ;;
              src/rs/sdr/*)
                tests+=("mock_apt_tests" "device_stream_frozen_tests")
                ;;
              src/rs/fft/*)
                tests+=("fft_processor_tests" "capture_stitch_tests")
                ;;
              src/rs/stitching.rs)
                tests+=("capture_stitch_tests")
                ;;
              src/rs/simd/*)
                tests+=("fft_processor_tests")
                ;;
              src/rs/consts/*)
                tests+=("fft_processor_tests" "frequency_validation_tests")
                ;;
              *)
                run_all=true
                ;;
            esac
          done <<< "$changed_files"

          if [ "$run_all" = true ]; then
            run_selected_tests "${all_tests[@]}"
            exit 0
          fi

          if [ "${#tests[@]}" -eq 0 ]; then
            cargo nextest run --lib
            exit 0
          fi

          mapfile -t selected_tests < <(printf "%s\n" "${tests[@]}" | sort -u)
          run_selected_tests "${selected_tests[@]}"
        env:
          REDIS_URL: redis://localhost:6379
          UNSAFE_LOCAL_USER_PASSWORD: n-apt-dev-key

      - name: Upload Rust coverage
        uses: codecov/codecov-action@v4
        with:
          flags: rust
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: false

  # Rust Performance Tests (Release mode)
  rust-performance-tests:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs['rust-performance'] == 'true' || github.ref == 'refs/heads/main'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Install system dependencies
        run: sudo apt-get update && sudo apt-get install -y librtlsdr-dev

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Cache Rust dependencies
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: .
          cache-on-failure: true

      - name: Run Rust Performance Tests
        run: cargo --config .cargo/performance.toml test --test performance_tests --release -- --nocapture

  # WASM tests
  wasm-tests:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs.wasm == 'true' || github.ref == 'refs/heads/main'

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '26.x'
          cache: "npm"

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-unknown-unknown

      - name: Install wasm-pack
        run: cargo install wasm-pack --locked

      - name: Install dependencies
        run: npm ci --legacy-peer-deps

      - name: Run WASM tests
        run: npm run test:wasm

  # Integration tests
  integration-tests:
    runs-on: ubuntu-latest
    needs: detect-changes
    if: needs.detect-changes.outputs.integration == 'true'

    services:
      redis:
        image: redis
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '26.x'
          cache: "npm"

      - name: Install system dependencies
        run: sudo apt-get update && sudo apt-get install -y librtlsdr-dev

      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

      - name: Cache Rust dependencies
        uses: Swatinem/rust-cache@v2
        with:
          workspaces: .
          cache-on-failure: true

      - name: Install dependencies
        run: npm ci --legacy-peer-deps

      - name: Build WASM (if changed)
        if: needs.detect-changes.outputs.wasm == 'true' || github.ref == 'refs/heads/main'
        run: npm run build:wasm

      - name: Build Rust Backend
        run: npm run build:rust

      - name: Generate Encrypted Test Artifacts
        run: cargo test --test encryption_e2e_tests generate_test_artifacts -- --nocapture

      - name: Run integration tests (Affected Only on Branches)
        run: |
          if [ "${{ github.event_name }}" = "pull_request" ]; then
            changed_since="origin/${{ github.base_ref }}"
          else
            changed_since="${{ github.event.before }}"
          fi

          if [ -z "$changed_since" ] || [ "$changed_since" = "0000000000000000000000000000000000000000" ]; then
            npm run test:integration
          else
            ./node_modules/.bin/jest test/integration --runInBand --changedSince="$changed_since" --passWithNoTests
          fi
        env:
          REDIS_URL: redis://localhost:6379
          UNSAFE_LOCAL_USER_PASSWORD: n-apt-dev-key