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

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:

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

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

pnpm install

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

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.

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 – Tests summary language preference logic
• frontend/tests/lib/onboarding-summary-model.test.mjs – Validates onboarding summary models
• frontend/tests/lib/blocknote-markdown.test.ts – Covers BlockNote markdown integration

Running Jest Tests

Execute the frontend test suite from the repository root:

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 contains audio::pipeline::tests::mixing_window
• 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:

cargo test --workspace

The --workspace flag ensures all crate members listed in 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:

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 (Jest scripts) and 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.

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 and 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. This ensures comprehensive coverage of auxiliary crates and core modules within the Tauri backend architecture.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}