How to use shutdownWorker method in Cypress

I might try this:

cy.get(".ibxudA").find('.WildnessText-kRKTej').should('have.text',"Wildness")

or

cy.get(".ibxudA").find('.WildnessText-kRKTej').invoke('text').then((text) => {
    expect(text.trim()).equal('Wildness')
});

This might be a similar question: How do you check the equality of the inner text of a element using cypress?

Your route should point to just the path, not the full URL. Try changing it to cy.route("/admin/portfolio/putstrategy").as("updatetrategy")

I'm assuming it's just a snippet from your test, but if you don't have cy.server() before you call into cy.route(), you'll need to add that as well.

it()'s callbacks will be executed only after parent's one (context in your case). You can play with it in debugger and see it live:

So mocha will assign the final 'Test C' value and call the first it() callback after that.

To solve the problem as close as possible to the structure of you current approach, you can use mocha context to capture the value at the time you define the it() case. Unfortunately, I found the mocha shares the context object between all of it siblings. So I had to wrap each of the case inside a child context:

context('The Test', function () {
  let curTestStr = 'Test A'

  context(`This test is ${curTestStr}`, () => {
    it("test", function() {
      expect(this.curTestStr).to.eq('Test A')
    })
  }).ctx.curTestStr = curTestStr;

  curTestStr = 'Test B'
  context(`This test is ${curTestStr}`, () => {
    it("test", function() {
      expect(this.curTestStr).to.eq('Test B')
    })
  }).ctx.curTestStr = curTestStr;

  curTestStr = 'Test C'
  context(`This test is ${curTestStr}`, () => {
    it("test", function() {
      expect(this.curTestStr).to.eq('Test C')
    })
  }).ctx.curTestStr = curTestStr;
})

Please also note that you have to use a function callback to access variables from this. It will not work with an arrow function expression () => {}

This will not work because of the asynchronous nature of Cypress. Cypress themselves advises to use aliases to save values for later use.

https://docs.cypress.io/guides/core-concepts/variables-and-aliases

In you example you can put the value of cy.url() in an alias. Which you can get via cy.get('@aliasName') later:

Example:

    cy.url().as("schoolDistrictViewLink1");

    // do other things

    // when you need to use the value
    cy.get("@schoolDistrictViewLink1").then((url) => {
      cy.log(url);
    });

Once you have declared the body bodyParams as an object, just set it as property for body: key.

Cypress.Commands.add("GETRequest", (requestUrl, bodyParams) => {
    cy.request({
        method: 'GET',
        url: apiURL + requestUrl,
        form: true,
        headers: {
            Authorization: "Bearer " + token
        },
        body: bodyParams
    });
})

UPDATE: Now there's an NPM package for this

cypress-hmr-restarter - it listens to the websocket that webpack-dev-server uses to reload the page

npm install --save-dev cypress-hmr-restarter

in cypress/support/index.js:

// cypress/support/index.js
import 'cypress-hmr-restarter'

see https://github.com/cypress-io/cypress/issues/456#issuecomment-566499738

Older hacky solution:

You can add the following to cypress/support/index.js (or at the top of a spec file):

Cypress.on('window:before:load', (win)=>{
  const _consoleInfo = win.console.info
  win.console.info = function () {
    if (arguments[0].includes('App updated.')) {
      cy.$$('.restart', top.document).click()
    }
    return _consoleInfo.apply(win.console, arguments)
  }
})

This will work as long as you have webpack-dev-server info being printed to the console (there are no other hooks into the webpack reloading behavior I could find)

The $('.restart').click() is a hilariously simple way to trigger a test re-run

Alternatively, you could try this plugin which sets up its own watchers on your source files, and re-runs your tests when changes are detected: https://github.com/bahmutov/cypress-watch-and-reload

It's a bad practice use waits in cypress. I'd suggest use the playground

https://docs.cypress.io/guides/core-concepts/test-runner.html#Selector-Playground

to find your items. Try to follow the Uniqueness principle and use the cy.get('[data-test-selector=you-selector']); instead of wait. It'll wait for you.

For example, visit and cy.get the title page.

Also, if you have animations, it might cause DOM issues with back and forth. If you remove them it'll be faster and more stable.

I'm currently working at a large well-known company on our test tools and frameworks team. So while I'm no expert, it is something that's part of my job. I'm going to be talking specifically about web testing. Testing is somewhat different for native apps like iOS and Android and I'm not super familiar with those aspects.

The terminology between e2e (end to end) and integration tests is somewhat interchangeable, while unit tests have a more specific definition.

Generally e2e/integration tests should be runnable in dev and production environments. Depending on your setup, your dev environment is probably using some semi-frequently updated snapshot of your production db. In other cases, your local environment may be hitting the actual production db. There are pros/cons to both approaches, but it largely depends on the scale of your company or project. For example, if you're at a large company with dedicated teams you can see many changes a day hitting production databases vs a small team where a weekly snapshot of the prod db is probably good enough for testing locally. i At the base level, all integration tests should be treated as real. When dealing with web apps there are lots of other factors we have to take into account like different web browsers, network activity / availability, etc. So mocking out data for api calls would allow for super fast testing, but then adds another level of complexity with making sure the mocks stay up to date with the real-world database.

Running integration tests locally should more or less be doing the same thing against your dev server that they will be doing against staging and production. With the exception of having the app detecting whether its running in a dev, staging, or production environment to switch out URL's and various credentials, the app should be expected to behave exactly the same way.

In regards to your question about authentication, the answer is yes. Lets look at 2 examples that show different considerations.

Suppose your project is very small. You create some real accounts on production and your db gets snapshotted weekly for use in your local dev environment. You just run your integration tests with one or more of those users as needed. Since the local tests are only hitting your local db, you don't need to worry about the data being generated since it won't affect production. Other engineers on your team can use the same user(s) and not worry about it. If one engineer makes some changes to the db schema, ORM, etc then everyone just gets a new copy of the db snapshot and continues working.

Now for the other extreme. Suppose your project is very big. Millions of users and hundreds of employees all collectively making changes to the codebase and db every day. There are all kinds of ways that infrastructures are setup to handle various engineering tasks. There's too much data and the db changes too often to make using local snapshots feasible. At this scale, you're probably doing continuous integration and running your tests on every commit. You want to do that so that incoming changes don't make it to production and cause major problems. You're probably running your local dev environments against either a constantly updated staging database, or perhaps even against your production db itself. (Try planning for the staging db as it avoids a lot of other problems.)

Now, having just a small set of dedicated test users starts to be a problem. Tests are running all the time, both automated and by dozens of engineers all working on their own bits of work. Since the staging db is probably shared, you easily start getting weird conflicts as the same test user is doing all kinds of things and starts causing tests to fail. A good solution I've seen for this is a kind of test account checkout server. You create say 100 or 1000 (or more) test user accounts. When your integration tests run, they literally check out a test user account from the server. When the tests are done, the integration tests clean up whatever changes they made on that user and tell the checkout server that the user is free again. Then it randomly gets checked out by someone/something else and the cycle continues.

So the take aways that related directly to your question:

1. You should always have dedicated test user accounts that are exactly the same as regular user accounts, just dedicated to testing.
2. Depending on scale of team and project, if small a few dedicated accounts is fine. If working on a much larger scale, you need many more dedicated test accounts and probably want an automated service that allows individual test runs to checkout users as needed.
3. Tests should always clean up after themselves. If a test creates a TODO that gets stored in the db. When the test is done running, that TODO should be deleted from the db. If you aren't constant about this, you'll eventually run into bugs and issues where data is inconsistent. God forbid this happens in production.
4. Only worry about mocking data for unit tests, unless you're working in a very good and dedicated engineering environment where you have people dedicated to keeping the db mocks up to date all the time. If you can do that, your integration tests will be very fast and you don't really have to worry about the db stuff as much. But its hard to maintain this over time without dedicated support.

You have two possibilities: one, this is a bug in Cypress, or two, you're handling events wrong.

The fundamental way that Cypress works is by running events through the in-browser APIs, not simulating actual keyboard or mouse actions (source from a Cypress employee) so you can only simulate individual events that the browser listens for. So I took a look at the way Cypress does it and found that people have had problems with it in the past. You can try the snippet at the end of the Github discussion in that link, I'm not sure if that might make it work.

In this case, you're simulating a Click event with Event.ctrlKey set to true. (Or at least: that's what you want to happen.) To debug this further, I would log the event itself, and check if the event.ctrlKey is set:

• If it is false - there you go, it's a bug in Cypress.
• If it is true, then Cypress is working fine, you're just listening to the ctrl/click events in unusual ways, and if you switch to something like this you'll be good.

Good luck, and let me know how it goes!