Recommended Free Tools
A Cypress test is an automated specification that opens an application in a browser (or mounts a component there), performs user-like operations, and checks the resulting behavior with assertions. Cypress places test commands on its own asynchronous command queue, runs them in order, and automatically retries linked queries and assertions while the page changes. That combination gives developers browser-level feedback without writing explicit sleeps for every render.
What a Cypress test contains
Most Cypress tests are JavaScript or TypeScript files. A test groups a scenario with describe() and it() (or context() and specify()), then uses the cy API to drive the application and Chai-style assertions to verify outcomes.
describe('checkout', () => {
it('submits a valid order', () => {
cy.visit('/checkout')
cy.get('[data-cy="email"]').type('[email protected]')
cy.get('[data-cy="pay"]').click()
cy.contains('Order confirmed').should('be.visible')
})
})This is an executable specification: the commands describe what a user does, while the assertion states the observable result. A failing assertion stops the test and shows the command that failed, the page state, and browser console information in the runner.
How Cypress executes commands
The command queue, not Promises
Cypress commands are placed on a central asynchronous queue and then executed serially. They look promise-like, but Cypress explicitly says that “Cypress commands are not Promises and cannot be awaited.” Do not write await cy.get(...) or return a Cypress command from a function expecting a native promise.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →// Correct
cy.get('[data-cy="total"]').should('contain', '$42')
// Incorrect
const total = await cy.get('[data-cy="total"])To use a value yielded by a command, continue the Cypress chain or use .then():
cy.get('[data-cy="total"]').invoke('text').then((text) => {
expect(text.trim()).to.equal('$42')
})Browser and Node coordination
Cypress launches its own browser instance and an isolated profile. It coordinates browser-side execution with a Node server process and runs close to the application’s run loop instead of sending each operation through Selenium/WebDriver’s remote-command model. This architecture lets Cypress inspect the DOM, control network traffic, and display each command’s state in its runner.
The normal end-to-end flow
- Load a page.
cy.visit()navigates to a local or deployed application. - Query the DOM.
cy.get()selects elements by CSS;cy.contains()finds visible text. - Perform an action. Commands such as
.type()and.click()change application state. - Assert the result.
.should()checks text, visibility, URL, attributes, or any other exposed state.
it('adds a product to the cart', () => {
cy.visit('/products/widget')
cy.get('[data-cy="quantity"]').clear().type('2')
cy.get('[data-cy="add-to-cart"]').click()
cy.get('[data-cy="cart-count"]').should('have.text', '2')
})What Cypress retries automatically
Queries and assertions
Cypress links queries and assertions into a retryable chain. If the element is not present yet, or the assertion is not true, Cypress re-queries from the beginning of that linked chain until it passes or the timeout expires. This handles common asynchronous rendering such as a framework updating the DOM after a request.
cy.get('[data-cy="results"]')
.should('be.visible')
.and('contain', 'Payment complete')The documented default command timeout is 4 seconds. Override a single command when one operation legitimately needs longer:
cy.get('[data-cy="report"]', { timeout: 10000 })
.should('contain', 'Ready')Prefer a targeted timeout over raising the global value, because a global increase can make unrelated failures slow and hide performance regressions.
Actions run once
Before an action, Cypress checks actionability: the element must be present, visible, enabled, and not covered by another element, among other checks. Once actionable, a state-changing command such as .click() executes once. Cypress does not repeatedly click while waiting for a later assertion, because a second click could submit a form twice or create another record. Put the retryable assertion after the action, and make the application state deterministic.
Command retry-ability versus test retries
These are separate mechanisms. Command retry-ability waits for expected asynchronous UI changes within one attempt. Whole-test retries rerun the complete test after a failure and must be enabled explicitly. With retries: 2, Cypress can make one initial attempt plus two additional attempts, for up to three total attempts; beforeEach and afterEach run again for each attempt.
// cypress.config.js
const { defineConfig } = require('cypress')
module.exports = defineConfig({
retries: {
runMode: 2,
openMode: 0
}
})Retries can expose a transient failure, but they do not repair a race or a test that depends on another test’s data. Investigate the first failure and keep retries as a controlled CI policy rather than treating them as proof that a test is reliable.
Test isolation and browser environments
End-to-end test isolation is enabled by default. Before each test Cypress resets aliases, clock mocks, intercepts, spies, stubs, and viewport changes, and starts from a clean browser context. Tests should therefore create their own data or use an explicit API setup instead of relying on a previous test.
Cypress uses a browser it launches itself, not your personal browser session. Current documentation lists Chrome-family browsers, Firefox, and experimental WebKit; the selected browser must be installed locally or in CI. Browser availability and experimental status can change, so check the version’s release documentation when configuring a pipeline.
Types of Cypress tests
End-to-end tests
An end-to-end test visits the application and exercises a user-visible workflow: signing in, creating a record, submitting a form, or navigating between pages. It verifies that the browser, frontend, backend, and routing work together.
Component tests
A component test mounts a UI component directly in a real browser. It is useful for checking rendering, events, styles, and states without navigating through the whole application.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11import Button from './Button'
describe('<Button />', () => {
it('emits a click', () => {
const onClick = cy.stub().as('onClick')
cy.mount(<Button onClick={onClick}>Save</Button>)
cy.contains('Save').click()
cy.get('@onClick').should('have.been.calledOnce')
})
})API tests
cy.request() calls REST or GraphQL endpoints directly and lets you assert status, headers, body, and timing. API calls are also useful for seeding state before a UI flow.
cy.request('POST', '/api/users', { name: 'Ada' })
.then((response) => {
expect(response.status).to.equal(201)
expect(response.body.name).to.equal('Ada')
})Network interception
Cypress can intercept and stub requests so a test controls responses or observes traffic. Current documentation describes native network interception for Chrome, Chromium, and Edge starting in Cypress 16; verify the behavior for your installed version and browser before relying on a version-specific setup.
Interactive authoring and debugging
Run cypress open to launch the interactive runner. It watches relevant files, reruns the active spec after edits, and displays each command in a time-travel-style interface. Select a command to inspect the DOM snapshot and the state at that point in the test. In CI, use the run mode to execute specs headlessly and publish results through your chosen CI workflow.
Keep specs independent: each should pass alone and in a suite. Shared server data, mutable accounts, and order-dependent tests are common causes of nondeterministic failures. Prefer stable selectors such as data-cy attributes over CSS classes that exist only for styling.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Troubleshooting common failures
“Timed out retrying”
The query found no matching element or the assertion stayed false until the timeout. Check the selector, confirm the page reached the expected route, and inspect the runner snapshot. If the operation is legitimately slow, set a per-command timeout rather than adding a fixed wait.
Click is prevented
Cypress found the element but it was covered, animating, disabled, or outside the actionable viewport. Wait for the UI state that makes the control usable, remove an unexpected overlay, or fix the application’s loading state. Using { force: true } bypasses safety checks and should be reserved for a deliberate test of hidden behavior.
Value is unavailable outside the chain
A command has not produced its yield when ordinary JavaScript runs. Move dependent logic into .then() or continue chaining; do not use await with Cypress commands.
Tests pass only in a particular order
Reset data and browser state in setup, avoid relying on aliases from another test, and run the failing spec by itself. Isolation is intended to reveal this hidden dependency rather than mask it.
Free tools Windows power users keep installed
One-click scans. No signup required.
Interception behaves differently in CI
Confirm the CI browser, Cypress version, and interception support match your local setup. Network timing, cross-origin rules, and experimental browser support can be version-sensitive.
Performance, reliability, and cost decisions
Use API setup for expensive prerequisite data, component tests for fast feedback on isolated UI behavior, and end-to-end tests for a smaller set of critical workflows. Avoid arbitrary sleeps: they lengthen every run and still fail when the application is slower than the chosen delay. Let linked queries retry, assert meaningful state, and use test retries only as an explicit policy. Cypress itself is the test runner; recording, replay, parallelization, spec prioritization, and auto-cancellation are associated with Cypress Cloud and should be evaluated separately from local test execution.
Or skip the browser setup
If your goal is a clean screenshot of a page rather than an interactive Cypress assertion, ScreenshotNeo provides a single HTTP request and an MCP server for AI agents. It accepts consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each cleanup step can be disabled. Bot checks or CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and whether it was billed.
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for options such as full-page lazy-image loading, CSS-selector element capture, device and viewport presets, retina scale, PDF output, custom CSS or JavaScript, waits, request blocking, cookies and headers, geolocation, caching, signed links, asynchronous webhooks, bulk capture, and the usage API. Its MCP tools are take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Bottom line
Cypress tests are queued browser commands plus assertions. Queries and assertions retry until the UI reaches the expected state, actions execute once after actionability checks, and optional test retries rerun the whole attempt. With isolated tests, stable selectors, targeted timeouts, and the right mix of end-to-end, component, API, and network tests, Cypress provides a reproducible way to specify and debug browser behavior.
Frequently Asked Questions
Does Cypress use Selenium?
No. Cypress coordinates browser-side commands with a Node process and runs close to the application’s run loop instead of using Selenium/WebDriver’s remote-command model.
Does Cypress wait automatically?
It automatically retries linked queries and assertions until they pass or the command timeout is reached. State-changing actions are not repeated.
Can Cypress test APIs without opening a page?
Yes. Use cy.request() to call REST or GraphQL endpoints and assert the response directly.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteWhy can’t I await a Cypress command?
Cypress commands are queued commands, not native Promises. Continue the Cypress chain or consume a yielded value in .then().
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
