Run cypress tests in parallel

•

bulkarticlewriting

Updated on

To run Cypress tests in parallel, thereby significantly reducing your testing time, here are the detailed steps you can take:

👉 Skip the hassle and get the ready to use 100% working script (Link in the comments section of the YouTube Video) (Latest test 31/05/2025)

Check more on: How to Bypass Cloudflare Turnstile & Cloudflare WAF – Reddit, How to Bypass Cloudflare Turnstile, Cloudflare WAF & reCAPTCHA v3 – Medium, How to Bypass Cloudflare Turnstile, WAF & reCAPTCHA v3 – LinkedIn Article

0.0
0.0 out of 5 stars (based on 0 reviews)
Excellent0%
Very good0%
Average0%
Poor0%
Terrible0%

There are no reviews yet. Be the first one to write one.

​
Amazon.com: Check Amazon for Run cypress tests
Latest Discussions & Reviews:
  1. Understand the Need: Parallel testing in Cypress is crucial for large test suites. If your test suite takes 30 minutes to run sequentially, parallelization might cut it down to 5-10 minutes, assuming you have the resources.
  2. Choose a CI/CD Service: Cypress itself doesn’t natively parallelize tests across multiple machines out-of-the-box. You’ll need a CI/CD service like GitHub Actions, GitLab CI, CircleCI, Jenkins, or a dedicated Cypress parallelization service.
  3. Utilize cypress run --record --key <your_record_key>: This is the foundational command. To enable parallelization, you must record your test runs to the Cypress Dashboard.
    • Get a Project ID: In your cypress.json or cypress.config.js for Cypress 10+, add "projectId": "your-project-id". You can find this in your Cypress Dashboard.
    • Get a Record Key: Generate a new record key from your Cypress Dashboard project settings. Never commit this key directly to your repository. use environment variables.
  4. Configure Your CI/CD for Parallelism:
  5. Utilize cypress-parallel or start-server-and-test for local/custom splitting:
    • For local development or custom CI setups, tools like cypress-parallel can help distribute tests.
    • cypress-parallel: npx cypress-parallel -s "cypress run" -t 5 -d "cypress/e2e/*.cy.js" runs 5 threads, distributes files.
    • start-server-and-test: Useful for ensuring your application is up before Cypress runs across multiple instances.

By following these steps, you’ll leverage the Cypress Dashboard’s intelligent test balancing to distribute your test load efficiently across your CI/CD infrastructure, drastically cutting down your feedback loop.

The Imperative of Parallel Test Execution in Modern CI/CD

Long-running test suites can become a significant bottleneck, delaying deployments and frustrating development teams.

This is where parallel test execution for Cypress tests emerges not just as a convenience, but as an absolute necessity.

By dividing your comprehensive test suite across multiple machines or containers, you effectively transform a serial process into a concurrent one, drastically compressing execution times and ensuring that your team receives critical feedback on code changes in minutes, not hours.

Why Parallel Testing is More Than Just a “Nice-to-Have”

Think of your testing pipeline like a highway.

When tests run sequentially, it’s a single lane, and even with a fast car, you’re limited by the car in front. Introduction to android ui test automation

Parallel testing opens up multiple lanes, allowing many “cars” test files to run simultaneously. This isn’t merely about convenience.

It’s about optimizing resource utilization and maximizing developer productivity.

A 2023 report from software testing firm Tricentis highlighted that organizations embracing intelligent test automation and parallel execution saw a 40% reduction in release cycles on average, alongside a 25% improvement in defect detection rates.

This data underscores the profound impact on both speed and quality.

The Cost of Slow Feedback Loops

Slow test feedback can have a cascading negative effect on a development team. Efficient software quality management process

When a CI build takes an hour to complete, a developer who commits a change might wait that full hour to find out if their code broke something. This idle time is a direct loss of productivity.

Moreover, if multiple changes are committed during that hour, identifying the root cause of a failure becomes significantly more complex, as the failure could stem from any of the intermingled commits.

This leads to longer debugging cycles and increased “context switching” costs for engineers, which can be mentally taxing and lead to burnout.

From an ethical standpoint, it’s about respecting the time and effort of your team, providing them with the tools to work efficiently and with less frustration.

Architectural Approaches to Cypress Parallelization

Achieving true parallelization with Cypress requires a strategic architectural approach within your CI/CD environment. Unit testing in javascript

Cypress itself is designed to run tests serially within a single instance.

To scale this across multiple instances, you need an orchestration layer that can distribute the workload and aggregate the results.

This typically involves leveraging the Cypress Dashboard’s intelligent load balancing capabilities combined with the node-splitting features of your chosen CI/CD platform.

Leveraging the Cypress Dashboard for Intelligent Load Balancing

The Cypress Dashboard is arguably the most powerful tool for parallelizing your Cypress tests.

When you run Cypress with the --record flag and connect it to the Dashboard, it doesn’t just store your test results. it intelligently optimizes future test runs. How to set goals for software quality assurance

  • How it Works: The Dashboard tracks the historical duration of each test file and even individual tests within those files. When you initiate a parallel run across multiple CI nodes, the Dashboard acts as a central coordinator. It instructs each node which specific test files or test suites to run, prioritizing those that typically take longer or those that failed in previous runs a feature known as “spec prioritization”. This dynamic distribution ensures that all your CI nodes finish their work around the same time, maximizing efficiency and preventing situations where one node finishes early while others are still grinding through heavy specs. This is far superior to simple alphabetical splitting, which often leads to uneven load distribution.
  • Configuration: To enable this, your cypress.json or cypress.config.js needs your projectId, and your cypress run command must include --record --key $CYPRESS_RECORD_KEY --parallel. The $CYPRESS_RECORD_KEY should always be an environment variable for security reasons.

CI/CD Platform-Specific Parallelization Strategies

Different CI/CD platforms offer varying mechanisms to facilitate parallel test execution.

Understanding these nuances is crucial for effective implementation.

CircleCI’s parallelism and split-configs

CircleCI has robust built-in support for parallel test execution.

You define the number of parallel containers executors for a job using the parallelism key, and CircleCI automatically splits your test files among them.

  • Example Configuration .circleci/config.yml: 
    jobs:
  cypress-tests:
    docker:
     - image: cypress/browsers:node18.12.0-chrome107-ff107 # Use a suitable Cypress image
   parallelism: 4 # This will spin up 4 parallel containers
    steps:
      - checkout
     - run: npm install # Install dependencies
      - run:
          name: Run Cypress Tests


         command: npx cypress run --record --key $CYPRESS_RECORD_KEY --parallel
          environment:
           # CircleCI automatically sets these for parallel jobs
           # for Cypress Dashboard integration
            CYPRESS_PARALLEL_NODES: true
  • Behind the Scenes: CircleCI uses its own internal logic to distribute test files or specs across the parallelism count. When combined with --record --parallel in Cypress, CircleCI works hand-in-hand with the Cypress Dashboard to ensure optimal distribution. The Dashboard then truly takes over the intelligent load balancing.

GitHub Actions with Matrices and Custom Scripting

GitHub Actions, while incredibly powerful, doesn’t have a direct parallelism keyword like CircleCI that automatically distributes files. Setup selenium on visual studio

Instead, you achieve parallelization using a strategy.matrix to create multiple parallel jobs, and then you typically need custom scripting or a dedicated GitHub Action to split the tests.

  • Example Configuration .github/workflows/cypress.yml:
    name: Cypress Parallel Tests
    on:
    cypress:
    runs-on: ubuntu-latest
    strategy:
    fail-fast: false # Allow all parallel jobs to complete even if one fails
    matrix:
    containers: # Define 3 parallel containers
    – uses: actions/checkout@v3
    – uses: actions/setup-node@v3
    with:
    node-version: 16
    – name: Install dependencies
    run: npm ci

    – name: Run Cypress tests in parallel Container ${{ matrix.containers }}

    run: npx cypress run –record –key ${{ secrets.CYPRESS_RECORD_KEY }} –parallel –group “CI Build ${{ github.run_id }}” –ci-build-id ${{ github.run_id }}
    env:
    # These environment variables are crucial for Cypress Dashboard’s parallelization
    # and tell Cypress which node it is and how many total nodes there are.
    CYPRESS_NODE_INDEX: ${{ matrix.containers – 1 }} # 0-indexed
    CYPRESS_TOTAL_NODES: ${{ strategy.matrix.containers | length }}

  • Note: The CYPRESS_NODE_INDEX and CYPRESS_TOTAL_NODES environment variables are essential for the Cypress Dashboard to understand how to distribute specs correctly across the parallel GitHub Actions jobs. This is manual in GitHub Actions compared to CircleCI’s automatic setup.

Jenkins and Custom Scripting

Jenkins is highly customizable, meaning parallelization often involves more manual scripting.

You’d typically use its Pipeline capabilities to define stages that run in parallel. Circleci vs travis ci

  • Example Jenkinsfile: 
    pipeline {
    agent any
    environment {


       CYPRESS_RECORD_KEY = credentials'cypress-record-key' // Get from Jenkins credentials
    }
    stages {
        stage'Setup' {
            steps {
                sh 'npm install'
            }
        }


       stage'Run Cypress Tests in Parallel' {
            parallel {
                stage'Cypress Node 1' {
                    steps {


                       sh 'CYPRESS_NODE_INDEX=0 CYPRESS_TOTAL_NODES=3 npx cypress run --record --key $CYPRESS_RECORD_KEY --parallel'
                    }
                }
                stage'Cypress Node 2' {


                       sh 'CYPRESS_NODE_INDEX=1 CYPRESS_TOTAL_NODES=3 npx cypress run --record --key $CYPRESS_RECORD_KEY --parallel'
                stage'Cypress Node 3' {


                       sh 'CYPRESS_NODE_INDEX=2 CYPRESS_TOTAL_NODES=3 npx cypress run --record --key $CYPRESS_RECORD_KEY --parallel'
}
  • Flexibility: Jenkins offers the most flexibility, allowing you to define complex parallelization strategies, including dynamic test splitting based on test file size or historical run times, though this would require custom shell scripts or Jenkins plugins.

Considerations for Local Parallelization and why it’s less common

While tools like cypress-parallel exist for local parallel execution, they are generally less efficient and less common for full-scale CI/CD.

  • Resource Intensive: Running multiple Cypress instances locally consumes significant CPU and memory resources. Your local machine might struggle to handle 4-5 parallel browsers effectively.
  • Lack of Intelligent Load Balancing: cypress-parallel typically uses a simpler distribution strategy e.g., round-robin or distributing based on file names rather than the intelligent, historical-data-driven balancing offered by the Cypress Dashboard.
  • Use Case: Local parallelization is primarily useful for developers wanting a quicker feedback loop on their machine before pushing to CI, or for specific niche scenarios. For robust, scalable, and reproducible parallelization, CI/CD and the Cypress Dashboard are the gold standard.

Pre-Requisites for Seamless Parallel Execution

Before you can effectively run your Cypress tests in parallel, certain foundational elements must be in place.

Overlooking these steps can lead to inefficiencies, unreliable test runs, or even security vulnerabilities.

It’s about building a robust testing infrastructure from the ground up, ensuring each component plays its part in a synchronized manner.

Centralized Test Reporting with Cypress Dashboard

The Cypress Dashboard is not merely a reporting tool. Launch of browserstack champions

It’s the intelligence hub for parallel test execution.

Without it, your parallel runs would be significantly less efficient and harder to manage.

  • The “Brain” for Parallelization: As discussed, the Dashboard actively monitors and balances the test load across your parallel CI nodes. It knows which tests ran on which node, how long they took, and which ones failed. This data is critical for intelligently distributing the remaining tests and ensuring all nodes finish around the same time.
  • Historical Data & Insights: Beyond parallelization, the Dashboard provides invaluable insights into your test health. You can track flakiness, identify slow tests, monitor test suite duration trends, and debug failing tests with recorded videos and screenshots. This data empowers teams to continuously improve their test suites and application quality.
  • Setup:
    1. Project ID: Link your Cypress project to the Dashboard by adding projectId: "your-project-id" to your cypress.json or cypress.config.js. You get this ID when you set up a new project in the Dashboard.
    2. Record Key: Obtain a unique record key for your project from the Dashboard settings. This key authenticates your CI runs with the Dashboard. Crucially, never hardcode this key in your repository. It must be passed as a secure environment variable e.g., CYPRESS_RECORD_KEY in your CI/CD pipeline. Treating this key like a password is a vital security practice.

Robust CI/CD Pipeline Configuration

Your CI/CD pipeline is the engine that drives parallel execution.

Its configuration needs to be meticulously crafted to support multiple concurrent test runs.

  • Adequate Resources: Ensure your CI/CD service e.g., CircleCI, GitHub Actions, Jenkins has enough allocated resources CPU, RAM, network bandwidth to handle the number of parallel containers you plan to run. If your containers are resource-starved, parallelization might ironically slow things down due to contention.
  • Consistent Environments: Each parallel node must operate in an identical environment. This means:
    • Same Node.js Version: Use a consistent Node.js version across all nodes.
    • Same NPM/Yarn Versions: Ensure your package manager is uniform.
    • Same Browser Versions: Critical for consistency. Using Cypress Docker images e.g., cypress/browsers:node16.14.0-chrome99-ff97 is highly recommended as they provide a consistent, pre-configured environment with all necessary browsers.
  • Dependency Installation: All necessary project dependencies and Cypress itself must be installed on each parallel node before tests begin. A common practice is npm ci clean install to ensure reproducible builds from package-lock.json.
  • Environment Variables: Correctly setting environment variables especially CYPRESS_RECORD_KEY and any application-specific variables is non-negotiable. Leverage your CI/CD platform’s secure secret management features for sensitive data.

Secure Handling of Record Keys and Sensitive Data

Security is paramount. Celebrating 10 years of making testing awesome

Exposing your Cypress record key or other sensitive data like API keys, database credentials directly in your code or public logs is a grave error.

  • Environment Variables: Always use environment variables for sensitive information. All major CI/CD platforms provide secure ways to store and inject these variables into your pipeline.
    • GitHub Actions: secrets context e.g., ${{ secrets.CYPRESS_RECORD_KEY }}
    • CircleCI: Project-level environment variables
    • Jenkins: Credentials Binding Plugin or withCredentials
  • Never Log Sensitive Data: Configure your logs to ensure sensitive data is never printed to the console.
  • Access Control: Restrict who has access to modify CI/CD configurations and view secrets. Implement role-based access control where possible.

By meticulously setting up these pre-requisites, you lay the groundwork for a robust, secure, and highly efficient parallel testing infrastructure that will serve your development team well.

It’s an investment that pays dividends in faster feedback, higher quality, and reduced developer frustration.

Implementing Parallel Execution Across Popular CI/CD Platforms

Once the pre-requisites are met, the next crucial step is to correctly configure your chosen CI/CD platform to spin up multiple parallel nodes and instruct Cypress to utilize them effectively.

This section will delve into practical examples and specific considerations for GitHub Actions, CircleCI, and Jenkins. How to test banking domain applications

GitHub Actions: Leveraging strategy.matrix for Parallelism

GitHub Actions is a highly flexible CI/CD platform that excels with its workflow and job definitions.

To achieve parallel Cypress runs, you primarily use the strategy.matrix feature.

  • Conceptual Approach: You define a matrix of containers or nodes, and GitHub Actions will create a separate job for each item in the matrix, all running concurrently. Each of these jobs will then run cypress run --parallel, and the Cypress Dashboard will intelligently distribute the tests among them.

  • Key Environment Variables for Cypress:

    • CYPRESS_NODE_INDEX: A 0-indexed number indicating which node the current job represents e.g., 0, 1, 2….
    • CYPRESS_TOTAL_NODES: The total number of parallel nodes expected in the run.

    These variables are essential for the Cypress Dashboard to correctly assign specs to each parallel job. How to test gaming apps

  • Example Workflow .github/workflows/cypress-parallel.yml:
    name: Parallel Cypress Tests
    on:

    cypress-run:
    # Define the matrix for parallel jobs
    fail-fast: false # Important: Ensures all parallel jobs complete even if one fails
    containers: # This will create 3 parallel jobs Container 1, Container 2, Container 3

    – name: Checkout
    uses: actions/checkout@v3

    – name: Set up Node.js
    uses: actions/setup-node@v3
    node-version: 16 # Use a consistent Node.js version

    run: npm ci # Use npm ci for reproducible builds Front end testing

    – name: Run Cypress tests in parallel Node ${{ matrix.containers }}

    # Crucial for Cypress Dashboard’s intelligent load balancing
    CYPRESS_NODE_INDEX: ${{ matrix.containers – 1 }} # Convert 1-indexed to 0-indexed
    CYPRESS_TOTAL_NODES: ${{ strategy.matrix.containers | length }} # Get total from matrix length

  • Important Considerations:

    • fail-fast: false: This is highly recommended. If one parallel job fails, you typically want the others to continue to gather full test coverage and debugging information.
    • --group and --ci-build-id: While not strictly required for parallelization, these flags are excellent for organizing your runs in the Cypress Dashboard. --ci-build-id ensures all parallel jobs are grouped under a single, unified run in the Dashboard.

CircleCI: Built-in parallelism Feature

CircleCI offers one of the most straightforward approaches to parallelizing Cypress tests due to its native parallelism feature.

  • Conceptual Approach: You define the parallelism key at the job level, and CircleCI automatically spins up that many containers. When Cypress runs with --record --parallel inside these containers, CircleCI intelligently integrates with the Cypress Dashboard to split the tests.
    version: 2.1 # Or 2.0, depending on your setup Difference between bugs and errors

    cypress-test-job:
    # Use a Cypress-provided Docker image for consistent environment

    – image: cypress/browsers:node16.14.0-chrome99-ff97
    parallelism: 4 # This is the magic! CircleCI will create 4 parallel containers
    – run: npm install

    name: Run Cypress Tests in Parallel

    # CircleCI automatically sets these for Cypress Dashboard integration
    # It injects CYPRESS_NODE_INDEX and CYPRESS_TOTAL_NODES for you
    CYPRESS_PARALLEL_NODES: true # A signal to Cypress that CircleCI handles node info

  • Benefits: Types of software bugs

    • Simplicity: Minimal configuration thanks to parallelism and automatic environment variable injection.
    • Efficiency: CircleCI’s integration with the Cypress Dashboard is highly optimized.

  • Node Selection: You can control which specific test files run on which node using cypress run --spec <spec_file_path>. However, for intelligent load balancing, it’s best to let the Cypress Dashboard handle the distribution with --parallel.

Jenkins: Flexible Parallel Stages with Custom Scripting

Jenkins, being highly customizable, requires a more manual approach to parallelization, typically leveraging its Pipeline syntax to define parallel stages.

  • Conceptual Approach: You define a parallel block within your Jenkinsfile, where each branch represents a parallel test node. Inside each branch, you manually set the CYPRESS_NODE_INDEX and CYPRESS_TOTAL_NODES environment variables for Cypress.

  • Example Jenkinsfile:
    # Securely retrieve the record key from Jenkins credentials

    CYPRESS_RECORD_KEY = credentials’your-cypress-record-key-id’ Webinar speed up releases with parallelization selenium

    TOTAL_NODES = 3 // Define the total number of parallel nodes here

    # Define each parallel node explicitly
    script {

    env.CYPRESS_NODE_INDEX = 0

    sh ‘npx cypress run –record –key $CYPRESS_RECORD_KEY –parallel’
    }

    env.CYPRESS_NODE_INDEX = 1 Fullpage js makes every user happy with browserstack

    env.CYPRESS_NODE_INDEX = 2

  • Considerations:

    • Manual Node Indexing: You are responsible for correctly setting CYPRESS_NODE_INDEX for each parallel stage.
    • Environment Variables: Ensure CYPRESS_TOTAL_NODES is consistently set across all parallel stages. It’s often best to define it once at the pipeline level as shown above or pass it dynamically if your node count varies.
    • Resource Management: With Jenkins, you have fine-grained control over which agent runs which stage, allowing for precise resource allocation.

By configuring your CI/CD pipeline correctly, you harness the power of distributed computing to dramatically accelerate your Cypress test feedback loop, moving from potentially hours to mere minutes for even the most extensive test suites.

Optimizing Test Suites for Parallelism

While simply enabling parallel execution through your CI/CD and the Cypress Dashboard yields significant speedups, further optimization of your test suite itself can unlock even greater gains.

This involves strategies to make individual tests faster, more independent, and less prone to flakiness.

Making Tests Independent and Atomic

The cornerstone of efficient parallelization is test independence.

If tests are coupled, relying on the state set by a previous test, parallel execution becomes a minefield of potential failures.

  • The Golden Rule: Each test it block should be able to run in isolation, regardless of the order or whether other tests are running concurrently.
  • Resetting State: Before each test, ensure your application and test environment are in a known, clean state.
    • Database Seeding/Truncation: Use cy.exec or cy.task to run backend scripts that seed or truncate your database. For example: cy.exec'npm run seed-db' or cy.task'db:reset'. This ensures each test starts with fresh data.
    • Browser State: Use cy.clearLocalStorage, cy.clearCookies, and cy.visit to ensure a clean browser state for each test.
    • API Mocking/Stubs: For complex scenarios, use cy.intercept to mock API responses, ensuring external dependencies don’t interfere with test isolation.
  • Avoid Shared State: Resist the temptation to share data or state between tests or even between beforeEach hooks and individual it blocks within the same describe block if that state is mutable and critical. If shared state is absolutely necessary, ensure it’s read-only or reset meticulously.
  • Example of Atomic Test Structure: 
    describe'User Authentication',  => {
  beforeEach => {
    // Ensure a clean state before each test
    cy.clearCookies.
    cy.clearLocalStorage.


   cy.task'db:resetUsers'. // Custom task to reset user data in DB
    cy.visit'/login'.
  }.



 it'should allow a valid user to log in',  => {
   cy.get'#username'.type'testuser'.
   cy.get'#password'.type'password123'.
    cy.get'button'.click.
    cy.url.should'include', '/dashboard'.



 it'should show error for invalid credentials',  => {
   cy.get'#username'.type'wronguser'.
   cy.get'#password'.type'wrongpassword'.


   cy.get'.error-message'.should'be.visible'.and'contain', 'Invalid credentials'.
}.

Identifying and Addressing Flaky Tests

Flaky tests are tests that sometimes pass and sometimes fail without any code change, making them notoriously problematic for parallel execution.

A flaky test on one node can falsely fail the entire build.

  • Causes of Flakiness:
    • Timing Issues: Asynchronous operations, network delays, animations not completing before assertions.
    • Race Conditions: Tests trying to interact with elements that aren’t yet ready.
    • Implicit Waits: Relying on Cypress’s default retryability without explicit waits or assertions.
    • Unstable Test Environment: Inconsistent data, slow CI/CD nodes, external service dependencies.
  • Solutions:
    • Explicit Waits: Use cy.wait with caution, preferably for network requests or better, cy.get.should'be.visible', cy.get.should'have.text', '...' which leverages Cypress’s retryability.
    • Cypress Retryability: Understand how Cypress retries commands and assertions. Use it to your advantage by asserting on elements’ existence, visibility, or text content.
    • Stubbing/Mocking APIs: For external API calls that might be slow or unreliable, use cy.intercept to control their responses and ensure consistent test behavior.
    • Test Isolation: Reiterate the importance of atomic tests. shared mutable state is a prime source of flakiness.
    • Cypress Dashboard Flakiness Detection: The Cypress Dashboard has excellent features to identify and report flaky tests, showing you historical pass/fail rates. Prioritize fixing these.
    • Component Testing: For UI components, consider Cypress Component Testing. It runs tests in isolation, often without a full server, significantly reducing flakiness and improving speed.

Optimizing Test File Organization and Size

How you structure your test files can also impact parallelization efficiency.

  • Smaller, Focused Test Files: Instead of one massive login.cy.js file with dozens of tests, consider breaking it down into login-success.cy.js, login-failure.cy.js, login-edge-cases.cy.js. This allows the Cypress Dashboard to distribute smaller, more manageable units of work across nodes more effectively.
  • Logical Grouping: Group related tests into separate describe blocks and it blocks within relevant files. This improves readability and maintainability.
  • Avoid Overly Long Specs: While the Cypress Dashboard aims for even distribution, having a few extremely long test files can still create bottlenecks, as one node might get stuck with a disproportionately large spec. Aim for a relatively even distribution of test run times across your files.
    • Strategy: Regularly review your Cypress Dashboard data. If you notice specific specs consistently taking much longer than others, investigate if they can be refactored or split.

By investing time in making your test suite robust, independent, and optimized for performance, you not only improve the effectiveness of parallel execution but also enhance the overall reliability and maintainability of your automated testing efforts.

Managing Test Data in Parallel Environments

One of the trickiest aspects of parallel testing is managing test data.

If multiple tests running concurrently try to modify the same data or rely on a shared, mutable state, you’re heading for chaos.

The goal is to ensure each parallel test run has its own pristine, isolated data environment.

Database Seeding and Truncation Strategies

For applications heavily reliant on databases, consistent and isolated data is non-negotiable for parallel tests.

  • Before Each Test/Suite:
    • Truncate and Seed: The most robust approach is to truncate relevant tables and re-seed the necessary data before each test or before each test file. This ensures every test starts with a known, clean slate.
    • Cypress cy.task for Backend Operations: Cypress runs in the browser, but it can communicate with your Node.js backend for tasks like database manipulation using cy.task.

      • Example cypress/plugins/index.js for older Cypress or cypress.config.js setupNodeEvents for Cypress 10+: 

        // cypress.config.js Cypress 10+


const { defineConfig } = require'cypress'.
const path = require'path'.
const fs = require'fs'.


const { Pool } = require'pg'. // Example for PostgreSQL

module.exports = defineConfig{
  e2e: {
    setupNodeEventson, config {
      on'task', {
        async 'db:reset' {
          // Connect to your database
          const pool = new Pool{


           connectionString: process.env.DATABASE_URL,
          }.
          try {


           // Example: Truncate tables


           await pool.query'TRUNCATE TABLE users, products RESTART IDENTITY CASCADE.'.


           // Example: Seed initial data


           await pool.query`INSERT INTO users username, email, password VALUES 'testuser', '[email protected]', 'hashed_password'.`.


           console.log'Database reset and seeded.'.
            return null. // Return null or a value to the test
          } catch err {


           console.error'Database reset failed:', err.
            throw err. // Propagate error
          } finally {
            await pool.end.
          }
        },


       // Add more tasks for specific seeding if needed
      }.
      return config.
    },
  },
}.

      • In your Cypress Test File:
        describe’Product Management’, => {
        beforeEach => { 

        cy.task'db:reset'. // Call the task to reset DB before each test
 cy.visit'/dashboard'.
 // Assume login logic here

        }.

        it’should create a new product’, => {
        // Test steps
        it’should display existing products’, => {

  • Dedicated Test Databases/Schemas: For very large suites or complex data requirements, consider running each parallel CI node against its own dedicated test database instance or a unique database schema. This provides absolute isolation but adds infrastructure overhead.
  • Transactional Tests Less Common in E2E: Some frameworks support transactional tests, where each test runs within a database transaction that is rolled back at the end. While powerful, this is less common for end-to-end tests due to browser interactions.

API Mocking and Stubbing for External Dependencies

Not all data comes from your internal database.

External APIs, third-party services, and microservices are common dependencies. Mocking and stubbing are crucial here.

  • cy.intercept: Cypress’s cy.intercept command is your best friend for controlling network requests.
    • Stubbing Responses: Provide predefined responses for specific API calls, ensuring consistency regardless of external service availability or response times. This speeds up tests and makes them reliable.
    • Error Simulation: Easily simulate network errors or specific API error codes without actually breaking your backend.
    • Example: 
      describe'User Profile',  => {
  beforeEach => {
    // Stub the user profile API request


   cy.intercept'GET', '/api/users/current', {
      statusCode: 200,
      body: {
        id: 1,
        username: 'JaneDoe',
        email: '[email protected]'
      }
    }.as'getCurrentUser'.
    cy.visit'/profile'.


   cy.wait'@getCurrentUser'. // Wait for the stubbed request to complete
  }.



 it'should display the current user profile',  => {


   cy.get'.profile-username'.should'have.text', 'JaneDoe'.


   cy.get'.profile-email'.should'have.text', '[email protected]'.
}.
  • Advantages:
    • Speed: No actual network calls, so tests run faster.
    • Reliability: Eliminates flakiness caused by slow or unavailable external services.
    • Isolation: Ensures tests don’t interfere with real external systems or each other.
    • Edge Case Testing: Allows you to easily test success, error, and loading states.

Frontend State Management and Local Storage

Frontend state, including local storage, session storage, and cookies, also needs careful management.

  • Cypress Commands:

    • cy.clearLocalStorage: Clears all local storage data.
    • cy.clearSessionStorage: Clears all session storage data.
    • cy.clearCookies: Clears all cookies for the current domain.

  • When to Use: Use these commands in your beforeEach or before hooks depending on your test isolation strategy to ensure each test starts with a clean browser state.

  • Example:
    describe’Shopping Cart’, => { 

    cy.clearLocalStorage. // Clear any saved cart data


cy.clearCookies.     // Clear session cookies if any
 cy.visit'/products'.

    it’should add items to cart and persist’, => {
    // … test steps …

    cy.reload. // Reload page to check persistence
    // … assertions …

By diligently managing test data and isolating environments, you prevent race conditions and data conflicts that can undermine the benefits of parallel test execution.

This systematic approach ensures that your parallel runs are not just fast, but also reliable and accurate.

Monitoring and Debugging Parallel Runs

Running Cypress tests in parallel is a must for speed, but it also introduces new complexities when it comes to monitoring progress and debugging failures. A single, sequential run is easy to watch.

A dozen concurrent runs, each with its own browser instance, requires a more sophisticated approach.

Utilizing the Cypress Dashboard for Real-time Insights

The Cypress Dashboard transforms the challenge of parallel monitoring into a streamlined experience.

It’s designed specifically to aggregate and visualize data from multiple parallel test runs.

  • Centralized View: All parallel jobs for a given CI build are grouped under a single, unified run in the Dashboard. This allows you to see the overall progress, success/failure rate, and total duration at a glance.
  • Run Status and Progress: The Dashboard provides real-time updates on which specs are running, which have passed, and which have failed across all your parallel nodes. You can see which node is currently processing which test file.
  • Test Failures at a Glance: Failed tests are prominently highlighted. You can quickly see:
    • The specific test that failed: Click on the failing test to drill down.
    • Error Messages and Stack Traces: Detailed error logs help pinpoint the issue.
    • Screenshots: Cypress automatically captures screenshots at the point of failure.
    • Videos: For a deeper understanding, Cypress records a video of the entire test run, which is particularly useful for debugging intermittent or tricky failures in parallel environments.
    • Console Logs and Network Requests: The Dashboard captures browser console logs and network requests made during the test run, providing crucial context for debugging.
  • Performance Metrics: Track average test run times, identify slow tests, and monitor the overall efficiency of your parallel setup. This data helps you continually optimize your test suite and infrastructure.
  • Flakiness Detection: The Dashboard automatically identifies and flags flaky tests based on their inconsistent pass/fail rates, allowing you to prioritize fixing them.
  • Set up Alerts: Configure notifications e.g., Slack, email for failed builds or flakiness spikes directly from the Dashboard.

Effective Logging and Reporting

Beyond the Cypress Dashboard, effective logging within your CI/CD pipeline and local environment is crucial for both monitoring and post-mortem debugging.

  • Structured Logging: Instead of just dumping raw output, strive for structured logs. This makes it easier to parse and analyze logs, especially when dealing with multiple parallel streams.
  • CI/CD Console Output: While the Cypress Dashboard is rich, the immediate console output in your CI/CD pipeline remains vital.
    • Summary Reports: Ensure your cypress run command produces concise summary reports at the end e.g., npx cypress run --reporter spec.
    • Error Highlighting: Configure your CI/CD to highlight errors in its console output for quick visibility.
    • Artifacts: Configure your CI/CD to store Cypress screenshots and videos as build artifacts. This ensures you have access to them even if the Dashboard link is temporarily unavailable or for compliance reasons.
      • Example GitHub Actions: 
        

- name: Upload Cypress artifacts on failure
  uses: actions/upload-artifact@v3
 if: failure # Only upload if the job fails
  with:
    name: cypress-artifacts
   path: cypress/videos/ # Or cypress/screenshots/
  • Custom Reporters: For advanced reporting needs, consider using custom Cypress reporters e.g., mocha-multi-reporter for multiple outputs, junit for Jenkins integration, html for shareable reports.
  • Integration with Test Management Tools: If you use external test management tools e.g., TestRail, Zephyr, ensure your CI/CD setup integrates with them to push Cypress test results, providing a comprehensive overview of test execution status.

Strategies for Debugging Failed Parallel Tests

Debugging a failure in a parallel run can feel like searching for a needle in multiple haystacks. Here’s a systematic approach:

  1. Start with the Cypress Dashboard: This is your first port of call. Identify the specific failed tests and review the associated video, screenshot, error message, and console logs. The video is especially powerful for understanding the sequence of events leading to the failure.
  2. Examine CI/CD Logs: If the Dashboard doesn’t provide enough context, dive into the raw CI/CD logs for the specific parallel job that failed. Look for:
    • Pre-test failures: Did a dependency fail to install? Did the application server fail to start?
    • Network issues: Any timeouts or connection errors specific to that node?
    • Resource exhaustion: Was the CI node running out of memory or CPU?
  3. Reproduce Locally if possible: If the failure isn’t obvious, try to reproduce it locally.
    • Run the specific failing spec: npx cypress run --spec "cypress/e2e/failing-test.cy.js"
    • Run in headless mode: Mimic the CI environment: npx cypress run --headless
    • Run in interactive mode: If local reproduction is difficult, run in interactive mode to step through the test: npx cypress open --spec "cypress/e2e/failing-test.cy.js"
  4. Isolate the Issue:
    • Data problems? Is the test data truly isolated?
    • Flakiness? Does the test fail intermittently? If so, focus on adding explicit waits, improving assertions, or mocking external dependencies.
    • Environment-specific? Does it only fail on CI, or can you reproduce it locally? Differences in browser versions, Node.js versions, or underlying OS can sometimes cause issues.
    • Resource contention? If failures are random and only happen under high parallel load, consider reducing the number of parallel nodes or increasing CI machine resources.
  5. Utilize cy.log and console.log: Temporarily add cy.log statements within your failing tests to print intermediate values or states to the Cypress Command Log and console. This can help trace the execution flow.
  6. Node.js Debugging: For issues originating in your cy.task functions or plugin file, use Node.js debugging tools e.g., node --inspect-brk within your CI environment if supported, or locally.

By combining the powerful visualization of the Cypress Dashboard with meticulous logging and systematic debugging strategies, you can maintain high visibility into your parallel test runs and quickly resolve any issues that arise.

Common Pitfalls and Troubleshooting

While running Cypress tests in parallel offers immense benefits, it’s not without its challenges.

Understanding common pitfalls and having a systematic approach to troubleshooting can save significant time and frustration.

Pitfall 1: Insufficient CI/CD Resources

This is arguably the most common issue.

Running multiple browser instances concurrently is resource-intensive.

If your CI/CD nodes containers, VMs are under-provisioned, you might experience:

  • Slower overall execution: Parallelization might paradoxically lead to longer total build times due to resource contention CPU throttling, I/O bottlenecks, memory swapping.
  • Flaky tests: Tests might time out or fail due to the application under test being slow to respond or the browser struggling to render.
  • Crashes: Browsers or Cypress processes might crash due to out-of-memory errors.
  • Solution:
    • Monitor Resource Usage: Use your CI/CD platform’s monitoring tools to observe CPU, memory, and disk I/O usage during parallel runs.
    • Increase Resources: Allocate more CPU cores, RAM, or faster disk I/O to your CI/CD nodes.
    • Reduce Parallelism: If increasing resources isn’t feasible, try reducing the number of parallel nodes to a level your infrastructure can comfortably handle. Start with 2-3 nodes and gradually increase while monitoring performance.
    • Use Optimized Docker Images: Leverage Cypress’s official Docker images e.g., cypress/browsers:nodeX-chromeY-ffZ which are pre-optimized for Cypress execution and often include necessary dependencies.

Pitfall 2: Test Data Conflicts and Lack of Isolation

If tests are not truly independent and share mutable data, parallel runs will lead to unpredictable failures.

  • Symptoms: Tests pass when run individually but fail when run in parallel, or results are inconsistent across different parallel runs.
    • Strict Isolation: Reinforce the rule: every test should be self-contained.
    • Database Reset/Seeding: Implement robust cy.task functions to reset and seed your database before each test or each test file. This is your primary defense against data conflicts.
    • API Mocking: Use cy.intercept extensively for external dependencies. This not only speeds up tests but completely eliminates external data dependencies.
    • Clear Browser State: Use cy.clearCookies, cy.clearLocalStorage, and cy.clearSessionStorage in beforeEach hooks to ensure a clean browser environment.

Pitfall 3: Unstable Test Environments Flakiness

Flaky tests are amplified in parallel environments.

One flaky test failing on one node can cause the entire parallel run to be marked as failed.

  • Symptoms: Random failures, tests passing on re-run without code changes, different results across parallel nodes.
    • Prioritize Flaky Test Resolution: Use the Cypress Dashboard’s flakiness detection to identify and fix these tests first.
    • Explicit Waits and Assertions: Replace arbitrary cy.waitms with assertions that leverage Cypress’s retryability e.g., cy.get'.element'.should'be.visible'.
    • Network Request Waiting: Use cy.wait'@alias' for API calls to ensure data has loaded before proceeding.
    • Visual Stability: For UI interactions, ensure elements are truly interactable e.g., cy.get'button'.should'not.be.disabled'.
    • Reduce Animation Speed: If animations cause issues, consider setting animationDistanceThreshold: 1 in cypress.json or disabling animations in your application’s test environment.

Pitfall 4: Incorrect CI/CD Configuration for Cypress Parallelism

Misconfiguration of environment variables or parallel job setup can prevent Cypress Dashboard from correctly distributing tests.

  • Symptoms: All tests run on a single node, tests are duplicated across nodes, or Cypress Dashboard reports “No tests found” or “Cannot parallelize.”
    • --record --key $CYPRESS_RECORD_KEY --parallel: Ensure this exact command is used in your CI/CD script.
    • Environment Variables: Verify CYPRESS_NODE_INDEX 0-indexed and CYPRESS_TOTAL_NODES are correctly set for each parallel job. Some CI/CDs like CircleCI handle this automatically. others like GitHub Actions or Jenkins require manual setup as shown in previous sections.
    • projectId in cypress.json/config.js: Confirm your projectId is correctly set and matches the one in your Cypress Dashboard.
    • Record Key Security: Ensure your CYPRESS_RECORD_KEY is passed securely as an environment variable and not accidentally hardcoded.

Pitfall 5: Long-Running or Bloated Test Files

Even with intelligent load balancing, a single extremely long test file can become a bottleneck if it runs on one node while others finish quickly.

  • Symptoms: One parallel job finishes significantly later than others, leading to wasted CI time.
    • Refactor Large Specs: Break down overly large test files into smaller, more focused specs.
    • Optimize Slow Tests: Use the Cypress Dashboard to identify the slowest tests and optimize them. This might involve:
      • Reducing the amount of data processed.
      • More effective use of mocking.
      • Skipping unnecessary UI interactions.
      • Moving complex logic to component tests if applicable.

By proactively addressing these common pitfalls, you can maximize the benefits of parallel Cypress test execution, ensuring faster, more reliable feedback loops for your development team.

Future Trends and Advanced Parallelization Techniques

As applications become more complex and test suites grow, new strategies and tools emerge to push the boundaries of speed and efficiency.

Distributed Test Execution Beyond CI/CD Runners

While CI/CD platforms are excellent for basic parallelization, some organizations require even more scalable or specialized solutions.

  • Cloud-based Test Grids: Services like BrowserStack, Sauce Labs, and LambdaTest offer large, distributed test grids that can run thousands of Cypress tests concurrently across various browsers, operating systems, and even mobile devices.
    • Benefits: Vast scalability, wide browser/OS coverage, managed infrastructure no need to maintain your own VMs.
    • Use Case: Ideal for large enterprises with diverse browser compatibility requirements or those needing to run tests on a massive scale.
  • Kubernetes for On-Demand Test Environments: Companies with Kubernetes infrastructure can leverage it to dynamically spin up Cypress test runners on demand.
    • Benefits: Highly scalable, cost-effective pay for what you use, great for complex multi-service applications.
    • Approach: Define Kubernetes deployments for Cypress runners, each pointing to a specific test file or a subset of tests, and orchestrate them using custom scripts or job schedulers.

AI/ML-Powered Test Optimization

The integration of Artificial Intelligence and Machine Learning is beginning to revolutionize how test suites are optimized, including for parallel execution.

  • Intelligent Test Selection: AI can analyze code changes and historical test data to identify only the relevant tests to run for a given code commit, reducing the overall test scope and thus the execution time, even before parallelization.
  • Predictive Parallelization: Beyond current Cypress Dashboard capabilities, AI could predict optimal parallelization strategies by learning from execution patterns, identifying potential bottlenecks, and dynamically adjusting resource allocation or test distribution.
  • Flakiness Prediction and Root Cause Analysis: AI models can identify subtle patterns that lead to flakiness, potentially even suggesting fixes or pinpointing root causes more quickly than human analysis.
  • Self-Healing Tests: While still emerging, AI could enable tests to “self-heal” by automatically adapting selectors or element interactions when minor UI changes occur, reducing maintenance overhead.

Cypress Component Testing and Unit Testing for Faster Feedback

While end-to-end tests are crucial, they are inherently slower.

Shifting testing left and utilizing faster testing paradigms is a key future trend.

  • Cypress Component Testing: This feature allows you to mount and test individual UI components in isolation, without the need for a full application server.
    • Benefits: Extremely fast feedback milliseconds to seconds, highly focused tests, easier debugging, less flakiness.
    • Impact on Parallelization: By moving many UI-centric tests from E2E to component tests, you reduce the overall load on your E2E parallel infrastructure, making the E2E suite even faster and more stable.
  • Unit Testing: Emphasize robust unit testing for business logic, utilities, and isolated functions.
    • Benefits: Fastest feedback loop, highly precise debugging, very low resource consumption.
    • Synergy: A well-tested codebase at the unit level means your E2E and component tests can focus on integration and user flows, rather than re-testing already verified logic.

Serverless Test Execution

Serverless platforms like AWS Lambda, Google Cloud Functions are emerging as potential environments for running Cypress tests.

  • Concept: Each test spec or a small group of specs could be executed in a separate serverless function, allowing for massive parallelization without managing servers.
  • Challenges: Cold starts, limited execution duration, managing browser environments within serverless functions can be complex. However, ongoing developments are making this more viable.

The future of parallel Cypress testing lies in increasingly intelligent orchestration, leveraging cloud-native solutions for boundless scalability, and integrating AI to optimize every facet of the testing process.

By adopting these advanced techniques and maintaining a layered testing strategy unit, component, E2E, teams can achieve unprecedented speed and reliability in their CI/CD pipelines.

Frequently Asked Questions

What is Cypress parallelization?

Cypress parallelization is the process of running multiple Cypress test files or specs simultaneously across different machines or containers in a CI/CD environment.

This is primarily facilitated by the Cypress Dashboard, which intelligently distributes the test workload to reduce the overall execution time of your test suite.

How does Cypress parallelization work with the Dashboard?

When you run Cypress with --record --parallel and connect it to the Cypress Dashboard, the Dashboard acts as a coordinator.

It receives information about the number of available CI nodes and their historical test run data.

It then intelligently distributes test files to each node, ensuring that the workload is balanced and all nodes finish around the same time, maximizing efficiency.

Do I need the Cypress Dashboard for parallel testing?

While it’s technically possible to implement a rudimentary form of parallelization without the Cypress Dashboard e.g., using custom scripts to split specs and run them across multiple local processes, the Cypress Dashboard provides critical features like intelligent load balancing, real-time monitoring, video/screenshot capture, and flakiness detection, making it the de facto standard and highly recommended approach for robust parallel testing.

What are the main benefits of running Cypress tests in parallel?

The primary benefit is a significant reduction in overall test suite execution time.

For instance, a suite that takes 60 minutes sequentially might finish in 15 minutes with 4 parallel nodes.

This leads to faster feedback loops, quicker deployments, increased developer productivity, and a more agile development process.

How many parallel nodes should I use for Cypress tests?

The optimal number of parallel nodes depends on several factors: the size and duration of your test suite, the complexity of your tests, the resources allocated to each CI/CD node CPU, RAM, and your budget.

Start with a conservative number e.g., 2-4 and gradually increase while monitoring resource usage and overall build times to find the sweet spot where performance gains plateau.

Can Cypress parallelize tests locally?

Yes, it’s possible to run Cypress tests in parallel locally using tools like cypress-parallel or by manually setting up multiple Cypress instances.

However, this is generally less efficient due to local resource constraints and the lack of intelligent load balancing provided by the Cypress Dashboard.

It’s primarily used for quick local development feedback rather than robust CI/CD.

What environment variables are crucial for Cypress parallelization in CI/CD?

The most crucial environment variables are CYPRESS_RECORD_KEY your unique key from the Cypress Dashboard, CYPRESS_NODE_INDEX a 0-indexed number indicating the current parallel node, and CYPRESS_TOTAL_NODES the total number of parallel nodes in the run. Your CI/CD platform will often help manage these.

How do I ensure test data isolation in parallel runs?

To ensure test data isolation, implement robust database seeding and truncation strategies using cy.task to reset your database before each test or test file.

Additionally, utilize cy.intercept for API mocking to control external dependencies and clear browser state using cy.clearLocalStorage, cy.clearCookies, and cy.clearSessionStorage in beforeEach hooks.

What are flaky tests and how do they impact parallelization?

Flaky tests are tests that sometimes pass and sometimes fail without any code changes, often due to timing issues or unstable environments.

In parallel runs, a flaky test on one node can cause the entire parallel build to fail, leading to wasted CI time and debugging effort.

Identifying and fixing flaky tests e.g., with explicit waits, better assertions, or mocking is crucial for reliable parallelization.

How do I debug a failed parallel Cypress run?

Start by reviewing the Cypress Dashboard.

It provides aggregated results, videos, screenshots, error messages, and console logs for each failed test across all parallel nodes.

If needed, drill down into the specific CI/CD job logs for that node, and if still unresolved, attempt to reproduce the failure locally by running the specific failing spec.

Can I run Cypress component tests in parallel?

Yes, Cypress Component Testing can also benefit from parallelization.

The same principles apply: use --record --parallel with the Cypress Dashboard and configure your CI/CD to spin up multiple nodes to run your component test files concurrently.

What is the --group and --ci-build-id flag used for?

The --group flag allows you to logically group runs in the Cypress Dashboard e.g., “Chrome Tests”, “Firefox Tests”, “CI Build”. The --ci-build-id flag is critical for parallel runs, as it ensures that all parallel jobs from your CI/CD matrix or parallel stages are grouped together as a single, unified run in the Cypress Dashboard for easier monitoring and reporting.

Is parallel testing better than sequential testing?

For large test suites, yes, parallel testing is almost always better.

It drastically reduces execution time, providing faster feedback.

However, it requires more CI/CD resources and careful test data management and isolation to be effective and reliable.

For very small test suites, the overhead of parallelization might not be worth it.

What if one parallel job fails? Does it stop the whole run?

This depends on your CI/CD configuration.

In GitHub Actions, you can set fail-fast: false in your strategy.matrix to ensure all parallel jobs complete even if one fails.

This is often desirable to gather full test coverage and debugging information before marking the overall build as failed.

How can I make my tests faster to optimize parallelization?

Beyond parallelization, optimize individual tests by:

  1. Ensuring strict test isolation clean state before each test.

  2. Using cy.intercept for API mocking to avoid slow network calls.

  3. Avoiding unnecessary waits and using Cypress’s built-in retryability.

  4. Breaking down large test files into smaller, more focused ones.

  5. Prioritizing fixing flaky tests.

What are common causes of slow parallel runs?

Common causes include:

  1. Insufficient CI/CD resources CPU, RAM, I/O.

  2. Overly long or complex individual test files that create bottlenecks.

  3. Network latency or slow application under test.

  4. Inefficient test data management e.g., slow database resets.

  5. Many flaky tests causing unnecessary re-runs or retries.

Can I use different browsers in parallel Cypress runs?

Yes, you can.

You can configure your CI/CD pipeline to have different parallel jobs run tests against different browsers e.g., one job for Chrome, another for Firefox, etc.. You would typically specify the browser using the --browser flag in your cypress run command for each respective job.

The Cypress Dashboard would then group these as separate “runs” or “groups” if you use the --group flag.

Does parallelization affect the order of test execution?

Yes, parallelization means test files and even individual tests within files if split at that granularity by the dashboard will run in an arbitrary order across different machines.

This is why strict test isolation and independence are paramount.

If your tests rely on a specific execution order, they will fail in parallel.

What’s the difference between --parallel and --spec in Cypress?

--spec tells Cypress to run only specific test files you define e.g., cypress run --spec "cypress/e2e/login.cy.js". --parallel is used in conjunction with --record and the Cypress Dashboard to distribute all available test files across multiple parallel CI nodes. You wouldn’t typically use --spec when aiming for full parallelization with the Dashboard, as it handles the spec distribution itself.

How do I handle secrets like CYPRESS_RECORD_KEY in CI/CD?

Always store your CYPRESS_RECORD_KEY and other sensitive information as secure environment variables or secrets within your CI/CD platform e.g., GitHub Actions Secrets, CircleCI Environment Variables, Jenkins Credentials. Never hardcode them directly into your configuration files or commit them to your repository.

This protects your access to the Cypress Dashboard and prevents unauthorized usage.

Leave a Reply

Your email address will not be published. Required fields are marked *