# Debug a single failing test in Tauri with Atlas in 2026 > Atlas helps Tauri developers debug single failing tests by running `cargo test` in isolation and navigating the call graph with `lsp` to fix underlying code issues. To debug a single failing test in a Tauri application, Atlas allows you to isolate the specific test using `bash` with `cargo test` filters, then work through the Rust core and webview code with `lsp` to identify the root cause. Atlas helps you fix the production code, not just the assertion, ensuring robust Tauri development in 2026. ## Key takeaways - Atlas uses `bash` to run `cargo test` with filters, isolating specific Tauri failures. - The `lsp` tool navigates Tauri's Rust core and webview code, tracing `#[tauri::command]` and `invoke` calls. - Atlas's `edit` and `apply_patch` tools facilitate precise code fixes in `src-tauri` and frontend files. - All Atlas actions, including running `cargo test` or `rustfmt`, are permission-gated for security. - Atlas provides unified diffs for approval and git patch snapshots for easy rollback of Tauri code changes. ## How Atlas isolates a failing Tauri test for debugging In 2026, Atlas streamlines debugging a single failing Tauri test by executing `cargo test` with specific filters via its `bash` tool. This approach ensures only the relevant test runs, significantly reducing output noise and focusing the debugging effort on the 1 problematic area. When a Tauri application has a failing test, Atlas uses its `bash` tool to run `cargo test` with the framework's built-in filter flag. For example, to run a test named `my_failing_test` within the `src-tauri` directory, Atlas would execute a command similar to `cd src-tauri && cargo test my_failing_test`. This isolates the test, making the output small enough for Atlas to reason about the assertion failure. This method mirrors how a developer would manually debug, leveraging the full power of `cargo test`'s filtering capabilities to pinpoint the exact issue within the Rust core or even the frontend suite if configured. Atlas ensures that any `cargo test` execution, whether in `src-tauri` or for the frontend, is permission-gated, requiring your approval before running. ## Navigating Tauri code with Atlas's lsp tool After isolating a failing Tauri test, Atlas employs its `lsp` tool to meticulously walk the call graph, providing deep insights into the Rust core and webview interactions. This allows Atlas to trace the execution flow from the test assertion back to the production code, often revealing the root cause within 2 or 3 steps. Once a specific Tauri test fails, Atlas reads the test code and the module it exercises. It then leverages its `lsp` tool to perform `goToDefinition` and `findReferences` operations. This is crucial for understanding the flow of data and logic within a Tauri application, which often involves `#[tauri::command]` handlers in Rust and `invoke` calls on the JavaScript side. Atlas can navigate from a failing assertion in a Rust test, through the `#[tauri::command]` definition, and even trace its usage in the frontend's `package.json` context. This comprehensive code exploration, powered by Atlas's AST-based indexing using tree-sitter, ensures that no relevant part of the Tauri codebase, from `src-tauri` to the frontend, is overlooked when forming a debugging hypothesis. ## Fixing Tauri code and verifying changes with Atlas Atlas facilitates fixing Tauri code by allowing developers to form hypotheses and check them directly within the terminal, using `edit` for temporary logging or `bash` for verbose flags. This iterative process ensures that the underlying code, not just the test assertion, is corrected, with changes verified by re-running the single test and then the full suite, often within 5 minutes. To fix the production code in a Tauri application, Atlas first helps form a hypothesis about the failure. It can then use its `edit` tool to add temporary logging statements, for instance, within a `#[tauri::command]` handler in `src-tauri/src/main.rs`, or re-run the test with a verbose flag through `bash` to gather more diagnostic information. Once the root cause is identified, Atlas uses `edit` to apply the fix. For changes spanning several hunks or multiple files, such as updating a capability in `src-tauri/capabilities/main.json` and its corresponding Rust implementation, Atlas can use `apply_patch` to ensure atomic and reliable modifications. Every file edit is presented as a unified diff for approval, and Atlas snapshots these changes as git patches for easy rollback. After the fix, Atlas re-runs the single test with `cargo test` to confirm the immediate issue is resolved, then runs the full test suite to prevent regressions, and finally removes any temporary logging. ## Atlas's permission-gated workflow for Tauri development Atlas operates with a robust permission-gated workflow, ensuring that every tool call, especially those interacting with your Tauri project's `src-tauri/tauri.conf.json` or `package.json`, requires explicit approval. This security model, active since 2026, prevents unintended modifications and provides developers with full control over agent actions, from running `cargo test` to applying `rustfmt`. Atlas's interaction with your Tauri project is always permission-gated. Before Atlas runs `cargo test` in `src-tauri` or executes any frontend test suite, it will prompt for your approval. This applies to all operations, including exposing a new `#[tauri::command]` and wiring its matching capability entry in `src-tauri/capabilities`, as a missing permission can fail silently at runtime. Atlas drafts a plan in a read-only plan agent and asks for permission before switching to a build agent to make changes. All proposed file edits, whether from `edit` or `apply_patch`, are presented as a unified diff for your approval before being written to disk. This granular control extends to formatting, where Atlas will ask for permission before running `rustfmt` on the Rust side or `prettier` on the frontend, ensuring that your codebase adheres to your team's standards while maintaining security and developer oversight. ## Steps 1. Isolate the failing test: Ask Atlas to run `cargo test` with a specific filter for your failing test, for example: "Run `cd src-tauri && cargo test my_failing_test` using `bash`." 2. Analyze the call path: Instruct Atlas to use the `lsp` tool's `goToDefinition` and `findReferences` to trace the execution from the test assertion through `#[tauri::command]` handlers and `invoke` calls. 3. Form and check hypothesis: Ask Atlas to add temporary logging with `edit` in relevant Rust files like `src-tauri/src/main.rs`, or re-run the test with verbose flags via `bash` to gather more data. 4. Fix the production code: Direct Atlas to use `edit` to apply the necessary code fix in the Rust core or frontend. For complex changes, use `apply_patch`. 5. Approve changes: Review the unified diff presented by Atlas for any proposed code edits and approve them before writing to disk. 6. Verify the fix: Ask Atlas to re-run the single failing test with `cargo test`, then run the full test suite to ensure no regressions. 7. Clean up: Instruct Atlas to remove any temporary logging statements added during the debugging process using `edit`. ## FAQ ### How does Atlas run `cargo test` for a specific Tauri test? Atlas uses its `bash` tool to execute `cargo test` commands with the appropriate filter flags, such as `cd src-tauri && cargo test my_specific_test`, directly within your Tauri project. ### Can Atlas debug issues across Tauri's Rust core and JavaScript frontend? Yes, Atlas works across the Rust core, the webview frontend, and `src-tauri/capabilities` files. It can read `#[tauri::command]` handlers and `invoke` calls on the JS side. ### What Atlas tools are used to navigate Tauri code during debugging? Atlas primarily uses the `lsp` tool with `goToDefinition` and `findReferences` operations to walk the call graph, from Rust tests to `#[tauri::command]` implementations. ### How does Atlas ensure code changes are safe in a Tauri project? Atlas operates with a permission-gated workflow. Every tool call, including `edit` and `apply_patch`, requires explicit approval, and all proposed changes are shown as a unified diff. ### Can Atlas help with Tauri capability issues? Yes, Atlas understands `src-tauri/capabilities` files. It can help expose new commands and wire matching capability entries, which is crucial since missing permissions fail silently at runtime. ### Does Atlas support Tauri's `rustfmt` and frontend formatters? Yes, Atlas can run `rustfmt` on the Rust side and `prettier` on the frontend, both behind a permission prompt, to maintain code style. ### How does Atlas handle temporary logging for debugging Tauri tests? Atlas can use its `edit` tool to insert temporary logging statements into your Tauri Rust or frontend code, and then remove them after the fix is verified. --- Canonical HTML: https://runatlas.sh/resources/stacks/debug-a-failing-test-in-tauri Source of truth: aeo_pages row `/resources/stacks/debug-a-failing-test-in-tauri` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.