Debugging is an essential part of the software development process, and Cypress is a popular open-source automation testing framework. Debugging is the process of correcting a software bug in the context of software engineering. To put it another way, it relates to locating, examining, and getting rid of faults. This activity starts when the program doesn’t work as it should and ends after the issue has been fixed and the software has been tested successfully.

Errors must be fixed at every level of debugging, which makes it a very difficult and time-consuming operation. In this article, we will discuss how to debug failed tests with Cypress. We will discuss what Cypress is, the benefits of using Cypress, why debugging is important for test automation, and the different Cypress debugging methods available. We will also explore the differences between the .pause() and .debug() commands and how to debug Cypress tests with Visual Studio Code IDE.

What is Cypress?

Cypress is a free, open-source test automation framework that is used for testing web applications. It is a JavaScript-based framework that is used to write end-to-end tests for web applications. It is easy to use and provides a lot of features, such as automatic waiting, time travel, and a command log.

What Are the Benefits of Using Cypress?

Cypress is an incredibly powerful tool when it comes to debugging, making it a highly popular choice among developers. It provides several benefits that make it an ideal choice for testers and developers alike.

  • Cypress is built on JavaScript and offers automated, end-to-end testing of web applications. This means that it can simulate user interactions, such as clicking on buttons and interacting with the website’s front end. This makes it much easier to identify false positives and quickly diagnose errors.
  • Cypress also incorporates a feature called ForceSync, which automatically keeps any changes made in the application in sync with the test, ensuring that no modifications go unnoticed.
  • It is fairly easy to install and set up, ensuring that developers can start debugging quickly. Along with this, Cypress offers a rich, interactive test runner and provides detailed debug reports, making it easy to analyze the results of the testing.
  • Furthermore, Cypress also offers excellent cross-browser testing capabilities and can be easily integrated with other CI/CD systems. This allows developers to view their tests, generate screenshots, and debug problems all within the same platform. All in all, injecting Cypress into your debugging workflow can be a great move and offer many long-term benefits.

Why is Debugging Important?

Debugging is an important part of software development and should not be overlooked. It is essential for ensuring the quality of the products produced and helps to prevent costly mistakes. Debugging is an iterative process that helps in detecting, finding, and resolving software problems. It can be used to identify potential security risks and to test whether software functions as expected. Debugging can also help to prevent data corruption by detecting errors that can cause corrupted data to be stored in the system.

Debugging can also help to identify performance issues, such as memory leaks or code logic problems that can impact the performance of the software. Debugging can also help in preventing errors and anomalies in the code due to incorrect logic, thereby making sure that the software does not contain any bugs. Debugging can be used to ensure quality assurance for software and ensure proper functioning across various devices, platforms, and browsers. It is an important part of the software development process and should be taken seriously.

How to Debug Failed Tests in Cypress?

Cypress provides various ways to debug failed tests. Here are some methods of Cypress debugging as follows:

1. Debugging Cypress Tests Using the Stack Trace

One of the most helpful ways to debug Cypress tests is by using the stack trace. This will provide information about the sequence of events that occurred when the test fails, allowing the user to identify root causes. Stack traces should provide an error code and a line number to indicate exactly where the error occurred. To access the stack trace, simply use the “.stack” attribute after the failed test has been completed.

Furthermore, a great way to enhance the effectiveness of your stack trace debugging is to add descriptive comments and log messages around problematic code. Doing this allows for better tracking of errors, as the source of the issue can be quickly identified from the message.

In addition, another benefit of stack trace debugging is that you can use it to pinpoint the specific failing test that is causing the failure of the entire suite. This is particularly helpful if you are running a large number of tests and want to focus on fixing a single test rather than debugging through the entire suite.

2. Debugging Cypress Tests Using the Debugger

Another way to debug the Cypress test is using the debugger. By using the debugger, users can pause Cypress upon a particular test failure and investigate the state of the test before continuing. To debug a Cypress test, users need to call the “.debug()” method from a test command.

When the debugger is invoked, Cypress will break execution and open the Chrome DevTools window within Cypress. This window provides a useful view into the state and behavior of the application under test and can be used to identify the root cause of a test failure.

In addition to the Chrome DevTools, the debugger also provides a range of inspection tools to help diagnose problems. For example, users can retrieve details about elements, measure text sizes, and check the state of the application. This can be done by simply selecting the elements and inspecting their properties. Moreover, the debugger also provides a JavaScript console, allowing users to inspect variables, evaluate expressions, and log the state of the application.

3. Debugging Cypress Tests Using Console Logs

Another way to debug Cypress tests is to use the console logs. Logging into the console presents the test commands as they are run, which can be useful for identifying potential issues while the test is running.

To access the console logs, users can open the command log in the Cypress GUI and view the log messages that are printed by the commands. This can be helpful to provide context to test errors, as the log messages can indicate the events leading up to the error.

In addition, console logs can also be used to detect performance issues with Cypress. For example, if tests are running abnormally slow, then the console logs may indicate which commands are taking the longest to execute, thus allowing users to investigate the root causes and optimize their tests.

4. Debugging Cypress with the .debug() Option

As mentioned earlier, users can use the .debug() option to debug their tests. This will open the Chrome DevTools window from where users can investigate the failed tests. Additionally, the .debug() option can be enabled in a few ways. For example, users can call the .debug() in the “on(‘fail’)” method or add a “debug: true” attribute to tests that may require debugging.


Additionally, the .debug() option also provides the “openDevTools” function. This function opens the DevTools window immediately, regardless of test failure. This can be especially helpful when users want to investigate potential issues while the test is running.

5. Debugging Tests with the .pause() Option

The .pause() option is another way to debug Cypress tests and can be used to pause tests at any given point. This allows users to inspect the application’s state and investigate the failure’s cause. Moreover, the .pause() option also provides the “forcePause” function, which can be used to pause the test under more complex conditions.

Additionally, users can also use the “resume()” method to resume the test after they have finished debugging the current state of the application. The benefit of this is that the user can carry out the investigation without having to restart the test from the beginning.

Difference between Cypress .pause() command and .debug() command

The main difference between the .pause() and .debug() commands is that the .pause() command pauses the test execution while the .debug() command allows developers to step through the code line by line. Additionally, the .debug() command allows developers to view the state of the application while the tests are running, which can help them identify potential issues with the code.

Debugging Cypress Tests with Visual Studio Code IDE

Visual Studio Code is a popular open-source Integrated Development Environment (IDE) for debugging Cypress tests. It provides a lightweight, user-friendly interface for debugging applications. Additionally, it supports debugging multiple browsers and provides a powerful tool for developers to step through the code line by line. Visual Studio Code also supports time-travel debugging, allowing developers to view the application’s state while the tests are running. This helps them identify potential issues with their code before they are released to production.


Debugging failed tests with Cypress is crucial in ensuring that your tests are running correctly. This guide provided an overview of the different ways to debug Cypress tests, including using the stack trace, the debugger, console logs, the .debug() option, and the .pause() option. Utilizing these tools and options can make troubleshooting much smoother and help you find the cause of any issues that may arise. If you are looking for options to begin your debugging using Cypress, then LambdaTest is one good platform, to begin with. Cypress is a modern web front-end testing tool built with JavaScript Mocha. It operates directly on the browsers without the need for Selenium. Its unique DOM manipulation technique makes it a very developer and QA-friendly tool.

You can run Cypress testing in the cloud across more than 40+ different browser versions by integrating LambdaTest with Cypress. A dependable, scalable, secure, and high-performing test execution platform developed for scalability, LambdaTest is favored by more than a million teams across 130+ countries. Run your Cypress tests simultaneously using LambdaTest to significantly shorten test running times. Speed up product releases while reducing the time it takes for developers to provide feedback. Protection Status