Implicit Should Syntax

## What an implicit assertion is An **implicit assertion** is one you chain straight onto a Cypress query instead of writing it as a separate statement. The first argument to `.should()` is a **chainer string** — a dotted path such as `have.text`, `be.visible` or `have.length` — and any arguments after it are the expected value. ```javascript cy.get('[data-cy=room-name]').should('have.text', 'Deluxe King') ``` The assertion belongs to the `cy.get()` in front of it. Cypress does not treat that lookup as finished until `have.text` is satisfied, so a room list that only paints after the availability API responds needs no explicit wait in the test. The check *is* the wait. ## The four call signatures Picking the wrong shape is the most common beginner mistake on this API. | Signature | Example on a booking page | What it checks | | --- | --- | --- | | `.should(chainer)` | `.should('be.visible')` | a property-style chainer that takes no value | | `.should(chainer, value)` | `.should('have.text', 'Deluxe King')` | the chainer against one expected value | | `.should(chainer, method, value)` | `.should('have.attr', 'href', '/rooms/12')` | a named member, then its expected value | | `.should(callbackFn)` | `.should(($rooms) => { /* ... */ })` | a function Cypress re-runs until nothing inside it throws | Where each chainer comes from matters when you are reading a failure. Cypress bundles three assertion libraries and no import is needed: - **Chai** supplies the general ones — `have.length`, `equal`, `match`, `include`. - **Chai-jQuery** supplies the DOM ones — `have.text`, `have.value`, `have.class`, `be.visible`, `exist`. - **Sinon-Chai** supplies the test-double ones — `have.been.calledWith`, `have.been.calledOnce` — and they only make sense when the subject is a spy or stub. A chainer Cypress cannot resolve is **not** retried: it fails at once with a message saying the chainer was not found, so a typo like `have.txt` surfaces in milliseconds rather than after the full timeout. ## The retry window The assertion has no timeout of its own. `.should()` accepts no options object — the window comes from the command the assertion is attached to. - `defaultCommandTimeout` is the global budget, **4000 ms** as of Cypress 16. - `cy.get('[data-cy=room-card]', { timeout: 10000 })` raises it for that one lookup, and every assertion chained after it shares that same ten-second window. - `{ timeout: 0 }` switches retrying off, turning the check into a single synchronous look at the page. - Writing `.should('be.visible', { timeout: 10000 })` extends nothing, because `.should()` reads a second argument as the **expected value**, not as options. When the window closes the command fails, and the report shows the assertion together with the last actual value Cypress saw — the text it did find, or how many `[data-cy=room-card]` elements were present. That number is usually enough to tell a slow render apart from a wrong selector. ## Chaining a second check with `.and()` `.and()` is not a different command. In the Cypress driver both names are registered against the same implementation, so `.and()` is purely a readability alias: ```javascript cy.get('[data-cy=room-card]') .should('have.length', 8) .and('be.visible') ``` Two consequences follow: 1. Every assertion in the group sees the **same subject reference**. Some chainers replace it — `have.attr` yields the attribute's value, `have.css` yields the computed value — so anything chained after one of those is asserting on a string, not on an element. 2. Assertions run **in order**, and the first failure ends the group. If `have.length` never reaches 8, the `be.visible` check is never evaluated and never reported. ## Where candidates go wrong - Reaching for a fixed pause before the assertion. The retry window already covers a slow render; a pause only makes a passing test slower and a failing one no more informative. - Chaining `.should()` off `cy` itself. It is a child command and needs a subject, so `cy.should('exist')` is an error. - Assuming the assertion waits for "the page". It re-checks the specific subject the chain produced and nothing else. - Treating a passing negative chainer as proof of behaviour. `should('not.have.class', 'sold-out')` is satisfied the instant that class is absent — including before the app has rendered anything. The short version: `.should(chainer, value)` is an assertion that doubles as the wait, its budget is `defaultCommandTimeout` unless you override it on the query, and `.and()` is the same command spelled for readability.