How to use warnIfPolicyMatches method in Cypress

So aparently I was using the wrong cypress module.

This is for react testing

npx cypress open-ct

or

npx cypress run-ct

cypress/plugins/index.js:

const injectDevServer = require("@cypress/react/plugins/react-scripts")

module.exports = (on, config) => {
  injectDevServer(on, config)
  return config
}

had the same problem as you. I used a then to push in an array my result instead of assert with a should.
Then assert the result in another then. It worked, but I really feel to hack the Cypress API which isn't made for this, shame.

2022 here and tested with cypress version: "6.x.x" until "10.x.x"

You could use { force: true } like:

cy.get("YOUR_SELECTOR").click({ force: true });

but this might not solve it ! The problem might be more complex, that's why check below

My solution:

cy.get("YOUR_SELECTOR").trigger("click");

Explanation:

In my case, I needed to watch a bit deeper what's going on. I started by pin the click action like this:

Then watch the console, and you should see something like:

Now click on line Mouse Events, it should display a table:

So basically, when Cypress executes the click function, it triggers all those events but somehow my component behave the way that it is detached the moment where click event is triggered.

So I just simplified the click by doing:

cy.get("YOUR_SELECTOR").trigger("click");

And it worked ????

Hope this will fix your issue or at least help you debug and understand what's wrong.

Try inverting/reversing your logic.

Get the element with the text, and then its tr parent:

cy.contains('Example Text').parent('.tr');

Try adding this in support/index.js:

import './commands'
Cypress.on('uncaught:exception', (err, runnable) => {
  // returning false here prevents Cypress from failing the test
  return false
})

This should avoid the uncaught:exception in the click() method.

From my understanding, this is what is happening: Remote development via SSH. Everything works fine except Cypress. If you run cypress open from a command line via SSH, it will try to launch Cypress on the remote machine.

To get Cypress to instead run on the local machine, the OP cloned the repo locally, ran npm install and runs cypress open from a local terminal. Since remote SSH is proxying the localhost, Cypress running locally is able to connect to the remote application. For example, VSCode SSH Remote proxies all ports automatically.

This is a simple approach. But any changes Cypress files will be on the local file system. You'll have to then copy/paste file changes manually from the local file system to the remote file system.

I've been trying to find the answer to this as well. It looks like Samba from WSL2 is pretty complicated - my idea was to install Cypress globally on my local machine and simply point it to a network drive.

I think it would work with following setup:

At root level of your app, jest.config.js:

module.exports = {
  testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.(jsx?|js?|tsx?|ts?)$",
  transform: {
    "^.+\\.jsx?$": "babel-jest",
    "^.+\\.mjs$": "babel-jest",
  },
  testPathIgnorePatterns: ["<rootDir>/build/", "<rootDir>/node_modules/"],
  moduleFileExtensions: ["js", "jsx", "mjs"]
}

And babel config babel.config.js:

const presets = [
  [
    "@babel/preset-env",
  ]
];

module.exports = { presets };

And finally your script to run the test in package.json:

"test": "jest --config=jest.config.js",

There are two ways I'm aware of to automatically do this:

1. The ESLint Jest plugin's jest/expect-expect rule, which will ensure that every test calls expect at least once. This can also be configured to allow other assertion functions/methods, like Cypress's "cy.**.should" or Supertest's "request.**.assert".

2. Use expect.assertions/expect.hasAssertions inside the tests, so that they will fail if the required number of expectations isn't met.

   This is a bit less automated, so may not solve the problem of people forgetting to include things, but will also catch cases where assertions exist but aren't reached (e.g. due to asynchronous code or no error being thrown). There's another rule in the ESLint plugin, jest/prefer-expect-assertions, which would check that you always use it, giving you the best of both worlds.

There's also a process-based approach: test-driven development. If you're always running the tests before you expect them to pass, you make sure they do indeed fail (and give useful feedback when they do so).

First, you need to add the env variables as empty strings on cypress.json:

{

  "env": {
    "userId": "1",
    "environment": "production",
    "baseUrl": "base URL",
    "username": "",
    "password": ""
  }
}

In main.yml file, you need to add the CYPRESS_ prefix to the variables:

env:
  CYPRESS_username: ${{secrets.CYPRESS_USERNAME}}
  CYPRESS_password: ${{secrets.CYPRESS_PASSWORD}}

Also, you should use the setup that can be found on cypress docs (https://docs.cypress.io/guides/continuous-integration/github-actions#Basic-Setup), example:

name: Cypress Tests

on: [push]

jobs:
  cypress-run:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      # Install NPM dependencies, cache them correctly
      # and run all Cypress tests
      - name: Cypress run
        uses: cypress-io/github-action@v2
        with:
          build: npm run build
          start: npm start
        env:
          CYPRESS_username: ${{secrets.CYPRESS_USERNAME}}
          CYPRESS_password: ${{secrets.CYPRESS_PASSWORD}}

You should also read this article: https://glebbahmutov.com/blog/keep-passwords-secret-in-e2e-tests/