Can I have cy.task retry until assertion passes?

[bahmutov]

cy.task is great but does not retry its action, even if it is idempotent code. In situations like "checking if the database has been updated" (see cypress-io/cypress-example-recipes@e6f3b4c#diff-11f8d1f12b6eb04ff4abd710d5e9d786) it would be perfect NOT to implement "retry until my assertion passes" logic in Node, but instead have cy.task behave like a regular Cypress command.

Something like this

cy.taks('find item in the database').should('deep.equal', {id: 1, text: 'something'})

[kuceb]

Is this one action, then the assertion will retry until it passes, or multiple actions? Cypress commands don't retry actions right?

[bahmutov]

it should rerun the single action until the assertion passes or times out

[kuceb]

So it will potentially seed my db multiple times? We don't click multiple times for example when retrying a cy.get(...').click().should(...)

[bahmutov]

Sure, it depends on the callback function. Maybe the user can designate if a callback can be retried. ```js cy.task('reset:db').then(...) // "reset:db" runs once cy.task('db:select', title, {timeout: 5000, idempotent: true}).should('deep.equal', ...) // "db:select" is retried until the assertion passes or 5 seconds timeout reached ```

[bahmutov]

better formatting

cy.task('reset:db').then(...)
// "reset:db" runs once
cy.task('db:select', title, {timeout: 5000, idempotent: true}).should('deep.equal', ...)
// "db:select" is retried until the assertion passes or 5 seconds timeout reached

[jennifer-shehane]

I don't think this is a great suggestion either. We have an existing open issue where we do accidentally run tasks multiple times which causes issues - I can see this being even more confusing. Do you have a real world use case for wanting this?

[hdavidzhu]

@bahmutov I have a lot of success with wrapping cy.task with cy.verifyUpcomingAssertions. Although it's not well documented, there are enough code samples for us to have what we need for "checking if the database has been updated"

# Look for data with a query. If chained with an assertion, retry until assertion passes (or timeout)
#
# @param collection [String]
# @param expression [Object] Mongo-like query
# @param options [Object]
#
# @return [Promise]
#   @resolve [Array<Object>] Array of docs
#
# @log [Object]
#   @property collection [String]
#   @property docs [Array<Object>] Resulting query fetch docs
#   @property expression [Object]
Cypress.Commands.add 'queryGet', (collection, expression, options = {}) ->
  # We want to reference the same console output to update the same log
  # @see https://github.com/cypress-io/cypress/blob/55b352a11d0a664517ae054c67432d98abc2389e/packages/driver/src/cy/commands/task.coffee#L14
  consoleOutput = {
    collection
    expression
  }

  options._log = Cypress.log({
    consoleProps: -> consoleOutput
    message: "#{collection} -> #{JSON.stringify(expression)}"
    name: 'queryGet'
  })

  tryQueryGet = ->
    cy.task('queryGet', {collection, expression}, {
      log: false
      timeout: options.timeout || Cypress.config('defaultCommandTimeout')
    }).then (docs) ->
      consoleOutput.docs = docs
      # TODO 2019-04-12: How does all this logging work? Without 'snapshot'ing, we can't get docs
      #   in the console logs. If we don't mutate 'consoleOutput' directly, we get duplicate Cypress
      #   messages
      #   @see https://github.com/cypress-io/cypress/blob/6a53b4bed1950d7112e59a195f760c38bb2ad519/packages/driver/src/cypress/log.coffee#L262
      #   @see https://github.com/cypress-io/cypress/search?q=_log.snapshot&unscoped_q=_log.snapshot
      options._log.snapshot().end()
      cy.verifyUpcomingAssertions(docs, options, {
        onFail: options._log
        onPass: options._log
        onRetry: tryQueryGet
      })

  return tryQueryGet()

Usage:

cy.queryGet('foobars', {
  '_id': 'SOMETHING'
}).should('have.length', 1) # The `should` would retry the db check
  .then ([foobar]) ->

[leolin0704]

Add a custom command to do this:

Cypress.Commands.add(
    'until',
    ({ it, become, delay = 5000, timeout = Cypress.config('defaultCommandTimeout') }) => {
        cy.log('Until start:');
        let lastestResult;
        setTimeout(() => {
            if (typeof become === 'function') {
                expect(become(lastestResult), `${become}`).to.be.true;
            } else {
                expect(lastestResult).to.be.equal(become);
            }
        }, timeout);

        const retry = () => {
            let originalResult = it();

            if (!Cypress.isCy(originalResult)) {
                originalResult = cy.wrap(originalResult, { log: false });
            }

            originalResult.then(result => {
                lastestResult = result;
                let checkResult = false;
                if (typeof become === 'function') {
                    checkResult = become(result);
                } else {
                    checkResult = isEqual(result, become);
                }

                if (checkResult) {
                    cy.log(`Until end: "${result}" is expected`);
                    return cy.wrap(result, { log: false });
                } else {
                    cy.log(`Until retry: "${result}" is not expected`);
                    cy.wait(delay);
                    return retry();
                }
            });
        };

        return retry();
    }
);

Usage:

it('should retry task', function() {
        let result = 0;
        cy.until({
            it: () => ++result,
            become: 3,
            timeout: 5000,
            delay: 500,
        });
    });

UI:

[jennifer-shehane]

Closing as resolved since there is a workaround outlined.

If you're experiencing a bug similar to this in Cypress, please open a new issue with a fully reproducible example that we can run. There may be a specific edge case with the issue that we need more detail to fix.