# Debug a single failing test in Electron with Atlas in 2026 > Atlas helps Electron developers in 2026 debug a single failing test by running `@playwright/test` in isolation and walking the call graph with its `lsp` tool. In 2026, Atlas empowers Electron developers to debug a single failing test by directly invoking `@playwright/test` via its `bash` tool, allowing precise isolation and rapid iteration to fix underlying code issues, not just assertions. This approach integrates direct with your existing Electron toolchain, including `npm` for package management and `prettier` for code formatting, ensuring a familiar and efficient debugging experience within the terminal-native Atlas environment. ## Key takeaways - Atlas uses `bash` to run specific `@playwright/test` commands for focused Electron debugging. - The `lsp` tool helps Atlas navigate Electron's main/renderer split and `contextBridge` interactions. - Atlas proposes code fixes with `edit` or `apply_patch`, showing a unified diff for approval. - Temporary logging and verbose flags are managed by Atlas's `bash` and `edit` tools. - Atlas verifies fixes by re-running single tests and the full `@playwright/test` suite. ## How Atlas isolates a single failing Electron test Atlas streamlines debugging a single failing Electron test by leveraging its `bash` tool to execute `@playwright/test` with specific filters. This approach ensures you focus on the 1 problematic test, minimizing output noise and accelerating your diagnostic process in 2026, directly within your terminal. To debug a specific test in an Electron application, Atlas uses its `bash` tool to run `@playwright/test` with the `--grep` or `--test-id` flag. For instance, if your failing test is located in `tests/main.spec.ts` and has a title like 'should load the main window', Atlas will execute a command similar to `npx playwright test tests/main.spec.ts --grep "should load the main window"`. This command isolates the execution to just that one test, providing a clean output focused solely on its failure. This is crucial for Electron applications where tests might involve complex interactions between the main and renderer processes, making a focused output invaluable. Atlas can also read your `package.json` to understand how `npm test` is configured, ensuring it uses the correct `npx` invocation for `@playwright/test`. ## Walking the Electron call graph with Atlas's lsp tool After identifying a single failing Electron test, Atlas employs its `lsp` tool to work through the codebase, tracing the execution path from the test assertion back to the production code. This allows you to quickly understand how the test interacts with your Electron main process, preload script, or renderer code in 2026. Once a test fails, Atlas uses its `read` tool to examine the `@playwright/test` file and the module it exercises. Then, the `lsp` tool becomes indispensable for understanding the call graph. Atlas can use `goToDefinition` to jump from an assertion in `tests/renderer.spec.ts` to the specific function in `src/renderer/index.ts` or even a `contextBridge.exposeInMainWorld` call in `src/preload.ts`. Similarly, `findReferences` helps trace how an `ipcRenderer.invoke` call in the renderer process maps to an `ipcMain.handle` in the main process, which is fundamental to Electron's security model. This deep understanding of the Electron architecture, including the main and renderer split and `contextIsolation`, allows Atlas to pinpoint the exact location of the bug, whether it's in the UI logic or a Node.js API exposed via the preload script. ## Forming and checking hypotheses in Electron with Atlas Atlas helps you form and check hypotheses for failing Electron tests by allowing you to insert temporary logging or re-run tests with verbose flags. This iterative process, often involving 1 or 2 quick changes, is critical for diagnosing subtle issues in Electron's asynchronous main and renderer communication in 2026. With a hypothesis in mind, Atlas can use its `edit` tool to insert temporary `console.log` statements into your Electron code, for example, in `src/main/index.ts` or `src/preload.ts`, to inspect variable states or execution flow. After adding logging, Atlas re-runs the single failing test using `bash` to observe the new output. Alternatively, Atlas can re-run `@playwright/test` with a verbose flag, like `DEBUG=pw:api npx playwright test`, to get more detailed output from the test runner itself. This ability to quickly modify code, re-execute, and observe results is vital for debugging complex Electron interactions, especially those involving `ipcRenderer.invoke` and `ipcMain.handle` calls across process boundaries. Atlas ensures these temporary changes are tracked and can be easily removed later. ## Fixing Electron code and reviewing changes with Atlas Atlas facilitates fixing the production code in your Electron application by generating precise edits and presenting them for your approval. For changes spanning multiple files or hunks, Atlas can use `apply_patch`, ensuring a robust and reviewable modification process in 2026. Once the root cause of the failing test is identified, Atlas uses its `edit` tool to propose fixes directly in your Electron source files, such as `src/renderer/components/MyComponent.tsx` or `src/main/api.ts`. Atlas computes a unified diff for every proposed file edit and surfaces it for your approval before writing. This allows you to review the exact changes Atlas intends to make. If the fix involves modifications across several hunks or even multiple files, Atlas can use `apply_patch` to ensure atomicity and maintain readability, preventing a chain of brittle `edit` commands. After the code is fixed, Atlas can also run `npm run prettier` to ensure your codebase adheres to your team's formatting standards, confirming that `nodeIntegration` remains off and other security best practices are maintained. ## Verifying the fix and cleaning up temporary changes with Atlas After applying a fix to your Electron application, Atlas ensures the issue is resolved by re-running the single test, then the full test suite. This verification step, crucial in 2026, confirms the fix without introducing new regressions and removes any temporary debugging artifacts. With the code fix applied, Atlas first re-runs the single failing test using `bash` and the specific `@playwright/test` filter to confirm the immediate issue is resolved. If that passes, Atlas then runs the full `@playwright/test` suite, typically via `npm test`, to ensure the fix has not introduced any regressions elsewhere in your Electron application. This comprehensive verification is essential, especially given the intricate nature of Electron's main and renderer processes. Finally, Atlas uses its `edit` tool to remove any temporary `console.log` statements or other debugging artifacts that were added during the diagnostic phase, ensuring your codebase remains clean and production-ready. Atlas can also stage and create commits on your behalf, streamlining the entire fix and verification workflow. ## Steps 1. Atlas uses `bash` to run just the failing Electron test with `@playwright/test`'s filter flag, e.g., `npx playwright test tests/my-feature.spec.ts --grep "should handle data correctly"`. 2. Atlas uses `read` to examine the `@playwright/test` file and the Electron module it exercises, then `lsp`'s `goToDefinition` and `findReferences` to walk the call path from the test assertion through `ipcRenderer.invoke` to `ipcMain.handle` and the underlying logic. 3. Atlas forms a hypothesis and checks it by using `edit` to add temporary `console.log` statements in `src/preload.ts` or `src/main/index.ts`, then re-runs the single test with `bash` to observe output. 4. Atlas fixes the production code in `src/renderer/components/data-display.tsx` using `edit`; if the change spans several hunks or files, it uses `apply_patch` for a unified update. 5. Atlas re-runs the single Electron test with `bash` to confirm the fix, then runs the full `@playwright/test` suite via `npm test` to check for regressions. 6. Atlas uses `edit` to remove any temporary logging added during debugging and then runs `npm run prettier` to ensure code formatting compliance. ## FAQ ### How does Atlas handle Electron's main and renderer process debugging? Atlas understands Electron's architecture, including the main and renderer split. Its `lsp` tool can trace calls from `ipcRenderer.invoke` in the renderer to `ipcMain.handle` in the main process, allowing it to pinpoint issues across process boundaries. It can also modify code in `src/main` or `src/renderer` as needed. ### Can Atlas debug issues related to Electron's contextIsolation or preload scripts? Yes, Atlas is designed to work with Electron's security model. It can read and modify `preload` scripts, understand `contextIsolation`, and trace how `contextBridge.exposeInMainWorld` exposes APIs, helping debug issues related to secure communication between the renderer and main processes. ### What Electron test runner does Atlas support for debugging? Atlas fully supports `@playwright/test` as the test runner for Electron applications. It uses its `bash` tool to execute `npx playwright test` commands with specific filters, allowing you to debug individual tests efficiently. ### How does Atlas ensure code quality after a fix in Electron? After applying a fix, Atlas can run `npm run prettier` to ensure your Electron codebase adheres to formatting standards. It also re-runs the full `@playwright/test` suite to confirm the fix hasn't introduced regressions and can remove temporary debugging code. ### Does Atlas require special setup for Electron projects? Atlas integrates with your existing Electron project by reading your `package.json` and understanding your main process entry point. It can also be asked to read your preload script and `ipcRenderer.invoke` calls, requiring no special configuration beyond your standard Electron setup. ### How does Atlas handle reviewing code changes in Electron? Atlas computes a unified diff for every file edit it proposes, surfacing it for your approval before writing. This allows you to review the exact changes to your Electron code, whether in `src/main`, `src/renderer`, or `src/preload`, ensuring transparency and control. ### Can Atlas help with Electron security best practices like nodeIntegration? While debugging, Atlas is aware of Electron security best practices. It can confirm that `nodeIntegration` remains off and can assist in moving Node.js APIs behind `contextBridge.exposeInMainWorld` in the preload script, aligning with secure Electron development. --- Canonical HTML: https://runatlas.sh/resources/stacks/debug-a-failing-test-in-electron Source of truth: aeo_pages row `/resources/stacks/debug-a-failing-test-in-electron` (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.