# How to Run Meetily Tests: Complete Guide for Frontend and Backend

> Learn how to run Meetily tests for both frontend and backend. Follow our guide to execute pnpm test for frontend and cargo test --workspace for backend verification.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-07-08

---

**Run Meetily's frontend tests with `pnpm test` and backend tests with `cargo test --workspace` to verify the entire application stack.**

Meetily is an open-source meeting assistant built by **Zackriya-Solutions** that combines a Next.js/React frontend with a Rust/Tauri backend. Understanding how to run Meetily tests ensures you can validate both the JavaScript UI logic and the Rust audio-processing core before contributing or deploying.

## Prerequisites

Before executing any test commands, install the required toolchains.

1. **Clone the repository**:

```bash
git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily

```

2. **Install JavaScript dependencies** (requires Node.js and pnpm):

```bash
pnpm install

```

3. **Install Rust toolchain** (required for backend tests):

```bash
rustup install stable
rustup component add rust-src

```

## How to Run the Frontend Test Suite

The frontend uses **Jest** as its test runner, automatically invoked through the npm scripts defined in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json).

### Understanding the Frontend Test Structure

Test files reside in `frontend/tests/lib/` and follow the pattern `**/*.test.{js,mjs,ts}`. Key test files include:

- [`frontend/tests/lib/summary-language-preferences.test.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/tests/lib/summary-language-preferences.test.js) – Tests summary language preference logic
- `frontend/tests/lib/onboarding-summary-model.test.mjs` – Validates onboarding summary models
- [`frontend/tests/lib/blocknote-markdown.test.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/tests/lib/blocknote-markdown.test.ts) – Covers BlockNote markdown integration

### Running Jest Tests

Execute the frontend test suite from the repository root:

```bash
pnpm test

```

This command runs Jest against all files matching the test pattern. You should see output similar to:

```

> meetily@0.4.0 test
> jest

 PASS  frontend/tests/lib/summary-language-preferences.test.js
 PASS  frontend/tests/lib/onboarding-summary-model.test.mjs
 PASS  frontend/tests/lib/blocknote-markdown.test.ts

Test Suites: 3 passed, 3 total
Tests:       27 passed, 27 total

```

Jest discovers tests automatically through its default configuration—no additional setup files are required because the test runner is a transitive dependency of Next.js and the React Testing Library chain.

## How to Run the Backend Test Suite

The Rust backend leverages **Cargo's built-in test framework** for unit and integration testing of the Tauri core.

### Understanding the Rust Test Structure

Rust source files are located under `frontend/src-tauri/src/`. Tests are embedded within source files using the `#[cfg(test)]` attribute. For example:

- [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) contains `audio::pipeline::tests::mixing_window`
- [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs) contains `audio::recording_manager::tests::start_stop`

### Running Cargo Tests

From the repository root (or the `frontend/src-tauri` directory), run:

```bash
cargo test --workspace

```

The `--workspace` flag ensures all crate members listed in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) are tested. Typical output includes:

```

   Compiling meetily v0.4.0
    Finished test [unoptimized + debuginfo] target(s) in 2.34s
     Running unittests (target/debug/deps/meetily-abc123)

running 12 tests
test audio::pipeline::tests::mixing_window … ok
test audio::recording_manager::tests::start_stop … ok
...
test result: ok. 12 passed; 0 failed; 0 ignored

```

Cargo automatically discovers any function annotated with `#[test]` inside `mod tests` blocks, making manual test registration unnecessary.

## Running All Tests in One Command

For continuous integration or pre-commit verification, combine both test suites:

```bash
pnpm test && cargo test --workspace

```

This sequential execution validates the JavaScript/TypeScript UI layer before testing the Rust audio-pipeline logic. If the frontend tests fail, the command exits immediately without running the backend suite.

## Summary

- **Frontend tests** use Jest and live in `frontend/tests/lib/**/*.test.{js,mjs,ts}` – run with `pnpm test`
- **Backend tests** use Cargo and live in `frontend/src-tauri/src/**/*.rs` within `#[cfg(test)]` blocks – run with `cargo test --workspace`
- **Combined execution** uses `pnpm test && cargo test --workspace` for full-stack verification
- **Key configuration files** are [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) (Jest scripts) and [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) (workspace manifest)

## Frequently Asked Questions

### What test runner does Meetily use for the frontend?

Meetily uses **Jest** for frontend testing. The test runner is automatically available through the `pnpm test` command because it is included as a transitive dependency of Next.js and React Testing Library, as specified in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json).

### Where are the Rust unit tests located in the Meetily repository?

Rust unit tests are co-located with source code under `frontend/src-tauri/src/`. Look for `#[cfg(test)]` annotated modules within files like [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) and [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs). These tests verify the audio-processing backend logic.

### Can I run Meetily tests without installing Rust?

Yes, you can run **only the frontend tests** without the Rust toolchain by executing `pnpm test`. However, to run the backend test suite, you must install Rust via `rustup install stable` because the backend relies on Cargo's test framework for the Tauri core.

### Why does `cargo test --workspace` include all crate members?

The `--workspace` flag instructs Cargo to test all packages defined in the workspace root manifest at [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). This ensures comprehensive coverage of auxiliary crates and core modules within the Tauri backend architecture.