{
  "doc": {
    "id": "api/commands/should",
    "title": "should | Cypress Documentation",
    "description": "Create an assertion in Cypress.",
    "section": "api",
    "source_path": "/llm/markdown/api/commands/should.md",
    "version": "48b03b5502f7aea1d0454750cce208f775403542",
    "updated_at": "2026-05-20T19:00:20.270Z",
    "headings": [
      {
        "id": "api/commands/should#should",
        "text": "should",
        "level": 1
      },
      {
        "id": "api/commands/should#syntax",
        "text": "Syntax",
        "level": 2
      },
      {
        "id": "api/commands/should#usage",
        "text": "Usage",
        "level": 3
      },
      {
        "id": "api/commands/should#arguments",
        "text": "Arguments",
        "level": 3
      },
      {
        "id": "api/commands/should#yields-learn-about-subject-management",
        "text": "Yields Learn about subject management",
        "level": 3
      },
      {
        "id": "api/commands/should#examples",
        "text": "Examples",
        "level": 2
      },
      {
        "id": "api/commands/should#chainers",
        "text": "Chainers",
        "level": 3
      },
      {
        "id": "api/commands/should#assert-the-checkbox-is-disabled",
        "text": "Assert the checkbox is disabled",
        "level": 4
      },
      {
        "id": "api/commands/should#the-current-dom-element-is-yielded",
        "text": "The current DOM element is yielded",
        "level": 4
      },
      {
        "id": "api/commands/should#value",
        "text": "Value",
        "level": 3
      },
      {
        "id": "api/commands/should#assert-the-class-is-form-horizontal",
        "text": "Assert the class is 'form-horizontal'",
        "level": 4
      },
      {
        "id": "api/commands/should#assert-the-value-is-not-jane",
        "text": "Assert the value is not 'Jane'",
        "level": 4
      },
      {
        "id": "api/commands/should#the-current-subject-is-yielded",
        "text": "The current subject is yielded",
        "level": 4
      },
      {
        "id": "api/commands/should#method-and-value",
        "text": "Method and Value",
        "level": 3
      },
      {
        "id": "api/commands/should#assert-the-anchor-element-has-href-attribute",
        "text": "Assert the anchor element has href attribute",
        "level": 4
      },
      {
        "id": "api/commands/should#assert-the-href-attribute-is-equal-to-users",
        "text": "Assert the href attribute is equal to '/users'",
        "level": 4
      },
      {
        "id": "api/commands/should#focus",
        "text": "Focus",
        "level": 3
      },
      {
        "id": "api/commands/should#assert-an-input-is-focused-after-button-click",
        "text": "Assert an input is focused after button click",
        "level": 4
      },
      {
        "id": "api/commands/should#function",
        "text": "Function",
        "level": 3
      },
      {
        "id": "api/commands/should#verify-length-content-and-classes-from-multiple-p",
        "text": "Verify length, content, and classes from multiple <p>",
        "level": 4
      },
      {
        "id": "api/commands/should#assert-class-name-contains-heading",
        "text": "Assert class name contains heading-",
        "level": 4
      },
      {
        "id": "api/commands/should#assert-text-content-of-3-elements",
        "text": "Assert text content of 3 elements",
        "level": 4
      },
      {
        "id": "api/commands/should#compare-text-values-of-two-elements",
        "text": "Compare text values of two elements",
        "level": 4
      },
      {
        "id": "api/commands/should#multiple-assertions",
        "text": "Multiple Assertions",
        "level": 3
      },
      {
        "id": "api/commands/should#chaining-multiple-assertions",
        "text": "Chaining multiple assertions",
        "level": 4
      },
      {
        "id": "api/commands/should#wait-until-the-assertions-pass",
        "text": "Wait until the assertions pass",
        "level": 3
      },
      {
        "id": "api/commands/should#notes",
        "text": "Notes",
        "level": 2
      },
      {
        "id": "api/commands/should#subjects",
        "text": "Subjects",
        "level": 3
      },
      {
        "id": "api/commands/should#how-do-i-know-which-assertions-change-the-subject-and-which-keep-it-the-same",
        "text": "How do I know which assertions change the subject and which keep it the same?",
        "level": 4
      },
      {
        "id": "api/commands/should#using-a-callback-function-will-not-change-what-is-yielded",
        "text": "Using a callback function will not change what is yielded",
        "level": 4
      },
      {
        "id": "api/commands/should#differences",
        "text": "Differences",
        "level": 3
      },
      {
        "id": "api/commands/should#whats-the-difference-between-then-and-should-and",
        "text": "What's the difference between .then() and .should()/.and()?",
        "level": 3
      },
      {
        "id": "api/commands/should#rules",
        "text": "Rules",
        "level": 2
      },
      {
        "id": "api/commands/should#requirements-learn-about-chaining-commands",
        "text": "Requirements Learn about chaining commands",
        "level": 3
      },
      {
        "id": "api/commands/should#timeouts-learn-about-timeouts",
        "text": "Timeouts Learn about timeouts",
        "level": 3
      },
      {
        "id": "api/commands/should#command-log",
        "text": "Command Log",
        "level": 2
      },
      {
        "id": "api/commands/should#history",
        "text": "History",
        "level": 2
      },
      {
        "id": "api/commands/should#see-also",
        "text": "See also",
        "level": 2
      }
    ]
  },
  "content": {
    "type": "root",
    "children": [
      {
        "type": "heading",
        "depth": 1,
        "children": [
          {
            "type": "text",
            "value": "should"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Create an assertion. Assertions are automatically retried until they pass or time out."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "An alias of "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/api/commands/and.md",
            "children": [
              {
                "type": "text",
                "value": "`.and()`"
              }
            ]
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Note: `.should()` assumes you are already familiar with core concepts such as "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/core-concepts/introduction-to-cypress.md#Assertions",
            "children": [
              {
                "type": "text",
                "value": "assertions"
              }
            ]
          }
        ]
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "Syntax"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": ".should(chainers).should(chainers, value).should(chainers, method, value).should(callbackFn)"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Usage"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Correct Usage"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.error').should('be.empty') // Assert that '.error' is emptycy.contains('Login').should('be.visible') // Assert that el is visiblecy.wrap({ foo: 'bar' }).its('foo').should('eq', 'bar') // Assert the 'foo' property equals 'bar'"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Incorrect Usage"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.should('eq', '42') // Should not be chained off 'cy'"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Arguments"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "chainers (String)"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Any valid chainer that comes from "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/references/assertions.md#Chai",
            "children": [
              {
                "type": "text",
                "value": "Chai"
              }
            ]
          },
          {
            "type": "text",
            "value": " or "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/references/assertions.md#Chai-jQuery",
            "children": [
              {
                "type": "text",
                "value": "Chai-jQuery"
              }
            ]
          },
          {
            "type": "text",
            "value": " or "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/references/assertions.md#Sinon-Chai",
            "children": [
              {
                "type": "text",
                "value": "Sinon-Chai"
              }
            ]
          },
          {
            "type": "text",
            "value": "."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "value (String)"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Value to assert against chainer."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "method (String)"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "A method to be called on the chainer."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "callbackFn (Function)"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Pass a function that can have any number of explicit assertions within it. Whatever was passed to the function is what is yielded."
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Yields "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/core-concepts/introduction-to-cypress.md#Subject-Management",
            "children": [
              {
                "type": "text",
                "value": "Learn about subject management"
              }
            ]
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "In most cases, `.should()` yields the same subject it was given from the previous command."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('nav') // yields <nav>  .should('be.visible') // yields <nav>"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "However, some chainers change the subject. In the example below, the second `.should()` yields the string `sans-serif` because the chainer `have.css, 'font-family'` changes the subject."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('nav') // yields <nav>  .should('be.visible') // yields <nav>  .should('have.css', 'font-family') // yields 'sans-serif'  .and('match', /serif/) // yields 'sans-serif'"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "`.should()` is an assertion, and it is safe to chain further commands that use the subject."
          }
        ]
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "Examples"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Chainers"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert the checkbox is disabled"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get(':checkbox').should('be.disabled')"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "The current DOM element is yielded"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('option:first')  .should('be.selected')  .then(($option) => {    // $option is yielded  })"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Value"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert the class is 'form-horizontal'"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('form').should('have.class', 'form-horizontal')"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert the value is not 'Jane'"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('input').should('not.have.value', 'Jane')"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "The current subject is yielded"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('button')  .should('have.id', 'new-user')  .then(($button) => {    // $button is yielded  })"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Method and Value"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert the anchor element has href attribute"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "// have.attr comes from chai-jquerycy.get('#header a').should('have.attr', 'href')"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert the href attribute is equal to '/users'"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('#header a').should('have.attr', 'href', '/users')"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Note: the `have.attr` assertion changes the subject from the original element to the attribute's value"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('#header a') // yields the element  .should('have.attr', 'href') // yields the \"href\" attribute  .and('equal', '/users') // checks the \"href\" value"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Focus"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert an input is focused after button click"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('#btn-focuses-input').click()cy.get('#input-receives-focus').should('have.focus') // equivalent to should('be.focused')"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Function"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Passing a function to `.should()` enables you to make multiple assertions on the yielded subject. This also gives you the opportunity to massage what you'd like to assert on."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Be sure not to include any code that has side effects in your callback function. The callback function will be retried over and over again until no assertions within it throw."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "You cannot invoke Cypress commands inside of a `.should()` callback function. Use Cypress commands before or after `.should()` instead."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Incorrect Usage"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('p').should(($p) => {  cy.log($p)  // ...})"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Correct Usage"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('p')  .should(($p) => {    // ...  })  .log()// orcy.get('p').then(($p) => {  // ...  cy.log($p)})"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Verify length, content, and classes from multiple `<p>`"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "<div>  <p class=\"text-primary\">Hello World</p>  <p class=\"text-danger\">You have an error</p>  <p class=\"text-default\">Try again later</p></div>"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('p').should(($p) => {  // should have found 3 elements  expect($p).to.have.length(3)  // make sure the first contains some text content  expect($p.first()).to.contain('Hello World')  // use jquery's map to grab all of their classes  // jquery's map returns a new jquery object  const classes = $p.map((i, el) => {    return Cypress.$(el).attr('class')  })  // call classes.get() to make this a plain array  expect(classes.get()).to.deep.eq([    'text-primary',    'text-danger',    'text-default',  ])})"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Warning Any value returned from a `.should()` callback function will be ignored. The original subject will be yielded to the next command."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('p')  .should(($p) => {    expect($p).to.have.length(3)    return 'foo'  })  .then(($p) => {    // the argument $p will be the 3 elements, not \"foo\"  })"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert class name contains `heading-`"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "<div class=\"docs-header\">  <div class=\"main-abc123 heading-xyz987\">Introduction</div></div>"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.docs-header')  .find('div')  // .should(cb) callback function will be retried  .should(($div) => {    expect($div).to.have.length(1)    const className = $div[0].className    expect(className).to.match(/heading-/)  })  // .then(cb) callback is not retried,  // it either passes or fails  .then(($div) => {    expect($div).to.have.text('Introduction')  })"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "You can even throw your own errors from the callback function."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.docs-header')  .find('div')  .should(($div) => {    if ($div.length !== 1) {      // you can throw your own errors      throw new Error('Did not find 1 element')    }    const className = $div[0].className    if (!className.match(/heading-/)) {      throw new Error(`No class \"heading-\" in ${className}`)    }  })"
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Assert text content of 3 elements"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Example below first asserts that there are 3 elements, and then checks the text content of each one."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "<ul class=\"connectors-list\">  <li>Walk the dog</li>  <li>Feed the cat</li>  <li>Write JavaScript</li></ul>"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.connectors-list > li').should(($lis) => {  expect($lis).to.have.length(3)  expect($lis.eq(0)).to.contain('Walk the dog')  expect($lis.eq(1)).to.contain('Feed the cat')  expect($lis.eq(2)).to.contain('Write JavaScript')})"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "For clarity you can pass a string message as a second argument to any `expect` assertion, see "
          },
          {
            "type": "link",
            "title": null,
            "url": "https://www.chaijs.com/guide/styles/#expect",
            "children": [
              {
                "type": "text",
                "value": "Chai#expect"
              }
            ]
          },
          {
            "type": "text",
            "value": "."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.connectors-list > li').should(($lis) => {  expect($lis, '3 items').to.have.length(3)  expect($lis.eq(0), 'first item').to.contain('Walk the dog')  expect($lis.eq(1), 'second item').to.contain('Feed the cat')  expect($lis.eq(2), 'third item').to.contain('Write JavaScript')})"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "These string messages will be shown in the Command Log giving each assertion more context."
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Compare text values of two elements"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "The example below gets the text contained within one element and saves it in a closure variable. Then the test gets the text in another element and asserts that the two text values are the same after normalizing."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "<div class=\"company-details\">  <div class=\"title\">Acme Developers</div>  <div class=\"identifier\">ACMEDEVELOPERS</div></div>"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "const normalizeText = (s) => s.replace(/\\s/g, '').toLowerCase()// will keep text from title elementlet titleTextcy.get('.company-details')  .find('.title')  .then(($title) => {    // save text from the first element    titleText = normalizeText($title.text())  })cy.get('.company-details')  .find('.identifier')  .should(($identifier) => {    // we can massage text before comparing    const idText = normalizeText($identifier.text())    // text from the title element should already be set    expect(idText, 'ID').to.equal(titleText)  })"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Multiple Assertions"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Chaining multiple assertions"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Cypress makes it easier to chain assertions together."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "In this example we use "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/api/commands/and.md",
            "children": [
              {
                "type": "text",
                "value": "`.and()`"
              }
            ]
          },
          {
            "type": "text",
            "value": " which is identical to `.should()`."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "// our subject is not changed by our first assertion,// so we can continue to use DOM based assertionscy.get('option:first').should('be.selected').and('have.value', 'Metallica')"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Wait until the assertions pass"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Cypress won't resolve your commands until all of its assertions pass."
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "// Application Code$('button').click(function () {  $button = $(this)  setTimeout(() => {    $button.removeClass('inactive').addClass('active')  }, 1000)})"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('button')  .click()  .should('have.class', 'active')  .and('not.have.class', 'inactive')"
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "Notes"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Subjects"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "How do I know which assertions change the subject and which keep it the same?"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "The chainers that come from "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/references/bundled-libraries.md#Chai",
            "children": [
              {
                "type": "text",
                "value": "Chai"
              }
            ]
          },
          {
            "type": "text",
            "value": " or "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/references/bundled-libraries.md#Chai-jQuery",
            "children": [
              {
                "type": "text",
                "value": "Chai-jQuery"
              }
            ]
          },
          {
            "type": "text",
            "value": " will always document what they return."
          }
        ]
      },
      {
        "type": "heading",
        "depth": 4,
        "children": [
          {
            "type": "text",
            "value": "Using a callback function will not change what is yielded"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Whatever is returned in the function is ignored. Cypress always forces the command to yield the value from the previous cy command's yield (which in the example below is `<button>`)"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('button')  .should(($button) => {    expect({ foo: 'bar' }).to.deep.eq({ foo: 'bar' })    return { foo: 'bar' } // return is ignored, .should() yields <button>  })  .then(($button) => {    // do anything we want with <button>  })"
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Differences"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "What's the difference between `.then()` and `.should()`/`.and()`?"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Using `.then()` allows you to use the yielded subject in a callback function and should be used when you need to manipulate some values or do some actions."
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "When using a callback function with `.should()` or `.and()`, on the other hand, there is special logic to rerun the callback function until no assertions throw within it. You should be careful of side affects in a `.should()` or `.and()` callback function that you would not want performed multiple times."
          }
        ]
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "Rules"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Requirements "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/core-concepts/introduction-to-cypress.md#Chains-of-Commands",
            "children": [
              {
                "type": "text",
                "value": "Learn about chaining commands"
              }
            ]
          }
        ]
      },
      {
        "type": "list",
        "ordered": false,
        "start": null,
        "spread": false,
        "children": [
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "text",
                    "value": "`.should()` requires being chained off a previous command."
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "type": "heading",
        "depth": 3,
        "children": [
          {
            "type": "text",
            "value": "Timeouts "
          },
          {
            "type": "link",
            "title": null,
            "url": "/llm/markdown/app/core-concepts/introduction-to-cypress.md#Timeouts",
            "children": [
              {
                "type": "text",
                "value": "Learn about timeouts"
              }
            ]
          }
        ]
      },
      {
        "type": "list",
        "ordered": false,
        "start": null,
        "spread": false,
        "children": [
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "text",
                    "value": "`.should()` will continue to "
                  },
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/core-concepts/retry-ability.md",
                    "children": [
                      {
                        "type": "text",
                        "value": "retry"
                      }
                    ]
                  },
                  {
                    "type": "text",
                    "value": " its specified assertions until it times out."
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "// timeout here will be passed down to the '.should()'// and it will retry for up to 10 secscy.get('input', { timeout: 10000 }).should('have.value', '10')"
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "// timeout here will be passed down to the '.should()'// unless an assertion throws earlier,// ALL of the assertions will retry for up to 10 secscy.get('input', { timeout: 10000 }).should(($input) => {  expect($input).to.not.be('disabled')  expect($input).to.not.have.class('error')  expect($input).to.have.value('US')})"
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "Command Log"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "Assert that there should be 8 children in a nav"
          }
        ]
      },
      {
        "type": "code",
        "lang": null,
        "meta": null,
        "value": "cy.get('.left-nav>.nav').children().should('have.length', 8)"
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "The commands above will display in the Command Log as:"
          }
        ]
      },
      {
        "type": "paragraph",
        "children": [
          {
            "type": "text",
            "value": "When clicking on `assert` within the command log, the console outputs the following:"
          }
        ]
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "History"
          }
        ]
      },
      {
        "type": "table",
        "align": [
          null,
          null
        ],
        "children": [
          {
            "type": "tableRow",
            "children": [
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "text",
                    "value": "Version"
                  }
                ]
              },
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "text",
                    "value": "Changes"
                  }
                ]
              }
            ]
          },
          {
            "type": "tableRow",
            "children": [
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/references/changelog.md#11-0-0",
                    "children": [
                      {
                        "type": "text",
                        "value": "11.0.0"
                      }
                    ]
                  }
                ]
              },
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "text",
                    "value": "Throw error if Cypress command used in callback"
                  }
                ]
              }
            ]
          },
          {
            "type": "tableRow",
            "children": [
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/references/changelog.md#0-11-4",
                    "children": [
                      {
                        "type": "text",
                        "value": "0.11.4"
                      }
                    ]
                  }
                ]
              },
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "text",
                    "value": "Allows callback function argument"
                  }
                ]
              }
            ]
          },
          {
            "type": "tableRow",
            "children": [
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/references/changelog.md#0-3-3",
                    "children": [
                      {
                        "type": "text",
                        "value": "< 0.3.3"
                      }
                    ]
                  }
                ]
              },
              {
                "type": "tableCell",
                "children": [
                  {
                    "type": "text",
                    "value": "`.should()` command added"
                  }
                ]
              }
            ]
          }
        ]
      },
      {
        "type": "heading",
        "depth": 2,
        "children": [
          {
            "type": "text",
            "value": "See also"
          }
        ]
      },
      {
        "type": "list",
        "ordered": false,
        "start": null,
        "spread": false,
        "children": [
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/api/commands/and.md",
                    "children": [
                      {
                        "type": "text",
                        "value": "`.and()`"
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/core-concepts/introduction-to-cypress.md#Assertions",
                    "children": [
                      {
                        "type": "text",
                        "value": "Guide: Introduction to Cypress"
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "/llm/markdown/app/references/assertions.md",
                    "children": [
                      {
                        "type": "text",
                        "value": "Reference: List of Assertions"
                      }
                    ]
                  }
                ]
              }
            ]
          },
          {
            "type": "listItem",
            "spread": false,
            "checked": null,
            "children": [
              {
                "type": "paragraph",
                "children": [
                  {
                    "type": "link",
                    "title": null,
                    "url": "https://example.cypress.io/commands/assertions",
                    "children": [
                      {
                        "type": "text",
                        "value": "cypress-example-kitchensink Assertions"
                      }
                    ]
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  },
  "token_estimate": 1940
}