Tauri 2.0 Testing Unit Tests and Integration Tests

// Basic Rust unit tests
// src-tauri/src/lib.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

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

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-1, 1), 0);
        assert_eq!(add(0, 0), 0);
    }

    #[test]
    fn test_multiply() {
        assert_eq!(multiply(2, 3), 6);
        assert_eq!(multiply(-2, 3), -6);
        assert_eq!(multiply(0, 5), 0);
    }

    #[test]
    #[should_panic]
    fn test_panic_example() {
        panic!("This test expects panic");
    }

    #[test]
    fn test_with_result() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err(String::from("Math is broken"))
        }
    }
}

// Run tests: cargo test

// Testing Tauri commands
use tauri::State;
use std::sync::Mutex;

pub struct AppState {
    pub counter: Mutex<i32>,
}

#[tauri::command]
pub fn increment_counter(state: State<AppState>) -> Result<i32, String> {
    let mut counter = state.counter.lock()
        .map_err(|e| format!("Lock error: {}", e))?;
    *counter += 1;
    Ok(*counter)
}

#[tauri::command]
pub fn get_counter(state: State<AppState>) -> Result<i32, String> {
    let counter = state.counter.lock()
        .map_err(|e| format!("Lock error: {}", e))?;
    Ok(*counter)
}

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

    #[test]
    fn test_increment_counter() {
        let state = AppState {
            counter: Mutex::new(0),
        };

        // First increment
        let result1 = increment_counter(State::from(&state));
        assert_eq!(result1.unwrap(), 1);

        // Second increment
        let result2 = increment_counter(State::from(&state));
        assert_eq!(result2.unwrap(), 2);

        // Verify final value
        let final_value = get_counter(State::from(&state));
        assert_eq!(final_value.unwrap(), 2);
    }

    #[test]
    fn test_get_counter_initial() {
        let state = AppState {
            counter: Mutex::new(5),
        };

        let result = get_counter(State::from(&state));
        assert_eq!(result.unwrap(), 5);
    }
}

// Testing async functions
use tokio;

async fn fetch_data(url: &str) -> Result<String, String> {
    // Simulate async operation
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    Ok(format!("Data from {}", url))
}

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

    #[tokio::test]
    async fn test_fetch_data() {
        let result = fetch_data("https://api.example.com").await;
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "Data from https://api.example.com");
    }

    #[tokio::test]
    async fn test_multiple_fetches() {
        let results = tokio::join!(
            fetch_data("url1"),
            fetch_data("url2"),
            fetch_data("url3")
        );

        assert!(results.0.is_ok());
        assert!(results.1.is_ok());
        assert!(results.2.is_ok());
    }
}

// Testing with custom test fixtures
struct TestDatabase {
    data: Vec<String>,
}

impl TestDatabase {
    fn new() -> Self {
        TestDatabase { data: vec![] }
    }

    fn insert(&mut self, value: String) {
        self.data.push(value);
    }

    fn get(&self, index: usize) -> Option<&String> {
        self.data.get(index)
    }
}

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

    fn setup() -> TestDatabase {
        let mut db = TestDatabase::new();
        db.insert("test1".to_string());
        db.insert("test2".to_string());
        db
    }

    #[test]
    fn test_database_insert() {
        let mut db = setup();
        db.insert("test3".to_string());
        assert_eq!(db.data.len(), 3);
    }

    #[test]
    fn test_database_get() {
        let db = setup();
        assert_eq!(db.get(0), Some(&"test1".to_string()));
        assert_eq!(db.get(1), Some(&"test2".to_string()));
        assert_eq!(db.get(2), None);
    }
}

// Property-based testing with proptest
// Cargo.toml: proptest = "1.0"
use proptest::prelude::*;

fn reverse_string(s: &str) -> String {
    s.chars().rev().collect()
}

#[cfg(test)]
mod prop_tests {
    use super::*;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn test_reverse_twice(s in ".*") {
            let reversed = reverse_string(&s);
            let double_reversed = reverse_string(&reversed);
            prop_assert_eq!(&s, &double_reversed);
        }

        #[test]
        fn test_reverse_length(s in ".*") {
            let reversed = reverse_string(&s);
            prop_assert_eq!(s.len(), reversed.len());
        }
    }
}

// Mock testing with mockall
// Cargo.toml: mockall = "0.12"
use mockall::*;

#[automock]
trait UserRepository {
    fn get_user(&self, id: i32) -> Option<String>;
    fn save_user(&mut self, id: i32, name: String) -> Result<(), String>;
}

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

    #[test]
    fn test_with_mock() {
        let mut mock = MockUserRepository::new();
        
        mock.expect_get_user()
            .with(eq(1))
            .times(1)
            .returning(|_| Some("John".to_string()));

        let result = mock.get_user(1);
        assert_eq!(result, Some("John".to_string()));
    }
}

// Integration test setup
// Cargo.toml
[dev-dependencies]
tauri = { version = "2.0", features = ["test"] }
tokio = { version = "1", features = ["full"] }

// tests/integration_test.rs
use tauri::test::{mock_builder, MockRuntime};

#[tokio::test]
async fn test_basic_command() {
    let app = mock_builder()
        .invoke_handler(tauri::generate_handler![my_command])
        .build(tauri::generate_context!())
        .expect("Failed to build app");

    let webview = app.get_webview_window("main").unwrap();
    
    // Execute command
    let result: String = webview
        .invoke("my_command", ())
        .await
        .unwrap();

    assert_eq!(result, "Expected result");
}

// Testing with WebDriver (end-to-end)
// Install: cargo install tauri-driver
// package.json
{
  "scripts": {
    "test:e2e": "tauri-driver --port 4444 & npm run test:wdio",
    "test:wdio": "wdio run wdio.conf.js"
  },
  "devDependencies": {
    "@wdio/cli": "^8.0.0",
    "@wdio/local-runner": "^8.0.0",
    "@wdio/mocha-framework": "^8.0.0",
    "@wdio/spec-reporter": "^8.0.0"
  }
}

// wdio.conf.js
export const config = {
  specs: ['./tests/e2e/**/*.spec.js'],
  maxInstances: 1,
  capabilities: [{
    'tauri:options': {
      application: '../src-tauri/target/release/app'
    }
  }],
  logLevel: 'info',
  bail: 0,
  baseUrl: 'http://localhost',
  waitforTimeout: 10000,
  connectionRetryTimeout: 120000,
  connectionRetryCount: 3,
  services: ['tauri'],
  framework: 'mocha',
  reporters: ['spec'],
  mochaOpts: {
    ui: 'bdd',
    timeout: 60000
  }
};

// tests/e2e/basic.spec.js
describe('Tauri App E2E Tests', () => {
  before(async () => {
    // Wait for app to be ready
    await browser.waitUntil(
      async () => await browser.execute(() => !!window.__TAURI__),
      { timeout: 10000 }
    );
  });

  it('should display app title', async () => {
    const title = await $('h1').getText();
    expect(title).toContain('My Tauri App');
  });

  it('should execute Tauri command', async () => {
    const result = await browser.execute(async () => {
      const { invoke } = window.__TAURI__.tauri;
      return await invoke('greet', { name: 'Test' });
    });
    
    expect(result).toBe('Hello, Test!');
  });

  it('should handle button click', async () => {
    const button = await $('#my-button');
    await button.click();
    
    const result = await $('#result').getText();
    expect(result).toBe('Button clicked!');
  });

  it('should update counter', async () => {
    // Click increment button 3 times
    const incrementBtn = await $('#increment');
    await incrementBtn.click();
    await incrementBtn.click();
    await incrementBtn.click();

    // Verify counter value
    const counter = await $('#counter').getText();
    expect(counter).toBe('3');
  });

  it('should handle file dialog', async () => {
    const selectBtn = await $('#select-file');
    await selectBtn.click();

    // Wait for dialog result
    await browser.pause(1000);

    const filePath = await $('#file-path').getText();
    expect(filePath).not.toBe('');
  });
});

// Testing IPC events
describe('Event Communication Tests', () => {
  it('should receive backend events', async () => {
    let eventReceived = false;
    let eventData = null;

    await browser.execute(() => {
      const { listen } = window.__TAURI__.event;
      return listen('test-event', (event) => {
        window.__testEventData = event.payload;
      });
    });

    // Trigger event from backend
    await browser.execute(async () => {
      const { invoke } = window.__TAURI__.tauri;
      await invoke('emit_test_event');
    });

    // Wait and check event
    await browser.waitUntil(
      async () => {
        const data = await browser.execute(() => window.__testEventData);
        return data !== undefined;
      },
      { timeout: 5000 }
    );

    const data = await browser.execute(() => window.__testEventData);
    expect(data).toBeDefined();
  });
});

// Performance testing
describe('Performance Tests', () => {
  it('should load app within 2 seconds', async () => {
    const startTime = Date.now();
    
    await browser.waitUntil(
      async () => await browser.execute(() => !!window.__TAURI__),
      { timeout: 10000 }
    );

    const loadTime = Date.now() - startTime;
    expect(loadTime).toBeLessThan(2000);
  });

  it('should execute command quickly', async () => {
    const startTime = Date.now();

    await browser.execute(async () => {
      const { invoke } = window.__TAURI__.tauri;
      await invoke('quick_command');
    });

    const executionTime = Date.now() - startTime;
    expect(executionTime).toBeLessThan(100);
  });
});

// React component testing with React Testing Library
// package.json
{
  "devDependencies": {
    "@testing-library/react": "^14.0.0",
    "@testing-library/jest-dom": "^6.0.0",
    "@testing-library/user-event": "^14.0.0",
    "vitest": "^1.0.0",
    "@vitest/ui": "^1.0.0"
  }
}

// vitest.config.ts
import { defineConfig } from 'vitest/config';
import react from '@vitejs/plugin-react';

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

// src/test/setup.ts
import '@testing-library/jest-dom';
import { vi } from 'vitest';

// Mock Tauri APIs
global.__TAURI__ = {
  tauri: {
    invoke: vi.fn(),
  },
  event: {
    listen: vi.fn(),
    emit: vi.fn(),
  },
};

// Component to test
import React, { useState } from 'react';
import { invoke } from '@tauri-apps/api/core';

interface CounterProps {
  initialValue?: number;
}

export const Counter: React.FC<CounterProps> = ({ initialValue = 0 }) => {
  const [count, setCount] = useState(initialValue);
  const [loading, setLoading] = useState(false);

  const handleIncrement = async () => {
    setLoading(true);
    try {
      const result = await invoke<number>('increment_counter');
      setCount(result);
    } catch (error) {
      console.error('Failed to increment:', error);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div>
      <h1>Counter: {count}</h1>
      <button onClick={handleIncrement} disabled={loading}>
        {loading ? 'Loading...' : 'Increment'}
      </button>
    </div>
  );
};

// Counter.test.tsx
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { vi, describe, it, expect, beforeEach } from 'vitest';
import { Counter } from './Counter';
import { invoke } from '@tauri-apps/api/core';

vi.mock('@tauri-apps/api/core');

describe('Counter Component', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('renders initial count', () => {
    render(<Counter initialValue={5} />);
    expect(screen.getByText('Counter: 5')).toBeInTheDocument();
  });

  it('increments count on button click', async () => {
    const user = userEvent.setup();
    vi.mocked(invoke).mockResolvedValue(6);

    render(<Counter initialValue={5} />);
    
    const button = screen.getByRole('button', { name: /increment/i });
    await user.click(button);

    await waitFor(() => {
      expect(screen.getByText('Counter: 6')).toBeInTheDocument();
    });

    expect(invoke).toHaveBeenCalledWith('increment_counter');
  });

  it('shows loading state during increment', async () => {
    const user = userEvent.setup();
    vi.mocked(invoke).mockImplementation(
      () => new Promise(resolve => setTimeout(() => resolve(6), 100))
    );

    render(<Counter />);
    
    const button = screen.getByRole('button');
    await user.click(button);

    expect(screen.getByText('Loading...')).toBeInTheDocument();
    expect(button).toBeDisabled();

    await waitFor(() => {
      expect(screen.getByText('Increment')).toBeInTheDocument();
    });
  });

  it('handles increment error', async () => {
    const user = userEvent.setup();
    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
    vi.mocked(invoke).mockRejectedValue(new Error('Backend error'));

    render(<Counter />);
    
    const button = screen.getByRole('button');
    await user.click(button);

    await waitFor(() => {
      expect(consoleError).toHaveBeenCalledWith(
        'Failed to increment:',
        expect.any(Error)
      );
    });

    consoleError.mockRestore();
  });
});

// Testing custom hooks
import { renderHook, waitFor } from '@testing-library/react';

function useTauriCommand<T>(command: string, args?: any) {
  const [data, setData] = useState<T | null>(null);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<Error | null>(null);

  const execute = async () => {
    setLoading(true);
    setError(null);
    try {
      const result = await invoke<T>(command, args);
      setData(result);
    } catch (e) {
      setError(e as Error);
    } finally {
      setLoading(false);
    }
  };

  return { data, loading, error, execute };
}

describe('useTauriCommand hook', () => {
  it('executes command successfully', async () => {
    vi.mocked(invoke).mockResolvedValue('success');

    const { result } = renderHook(() => 
      useTauriCommand<string>('test_command')
    );

    expect(result.current.loading).toBe(false);
    expect(result.current.data).toBe(null);

    await result.current.execute();

    await waitFor(() => {
      expect(result.current.data).toBe('success');
      expect(result.current.loading).toBe(false);
    });
  });
});

// Run tests: npm run test