/// <reference types="cypress" />

context("Assertions", () => {
  beforeEach(() => {
    cy.visit("https://example.cypress.io/commands/assertions")
  })

  describe("Implicit Assertions", () => {
    it(".should() - make an assertion about the current subject", () => {
      // https://on.cypress.io/should
      cy.get(".assertion-table")
        .find("tbody tr:last")
        .should("have.class", "success")
        .find("td")
        .first()
        // checking the text of the <td> element in various ways
        .should("have.text", "Column content")
        .should("contain", "Column content")
        .should("have.html", "Column content")
        // chai-jquery uses "is()" to check if element matches selector
        .should("match", "td")
        // to match text content against a regular expression
        // first need to invoke jQuery method text()
        // and then match using regular expression
        .invoke("text")
        .should("match", /column content/i)

      // a better way to check element's text content against a regular expression
      // is to use "cy.contains"
      // https://on.cypress.io/contains
      cy.get(".assertion-table")
        .find("tbody tr:last")
        // finds first <td> element with text content matching regular expression
        .contains("td", /column content/i)
        .should("be.visible")

      // for more information about asserting element's text
      // see https://on.cypress.io/using-cypress-faq#How-do-I-get-an-element’s-text-contents
    })

    it(".and() - chain multiple assertions together", () => {
      // https://on.cypress.io/and
      cy.get(".assertions-link")
        .should("have.class", "active")
        .and("have.attr", "href")
        .and("include", "cypress.io")
    })
  })

  describe("Explicit Assertions", () => {
    // https://on.cypress.io/assertions
    it("expect - make an assertion about a specified subject", () => {
      // We can use Chai's BDD style assertions
      expect(true).to.be.true
      const o = { foo: "bar" }

      expect(o).to.equal(o)
      expect(o).to.deep.equal({ foo: "bar" })
      // matching text using regular expression
      expect("FooBar").to.match(/bar$/i)
    })

    it("pass your own callback function to should()", () => {
      // Pass a function to should that can have any number
      // of explicit assertions within it.
      // The ".should(cb)" function will be retried
      // automatically until it passes all your explicit assertions or times out.
      cy.get(".assertions-p")
        .find("p")
        .should($p => {
          // https://on.cypress.io/$
          // return an array of texts from all of the p's
          // @ts-ignore TS6133 unused variable
          const texts = $p.map((i, el) => Cypress.$(el).text())

          // jquery map returns jquery object
          // and .get() convert this to simple array
          const paragraphs = texts.get()

          // array should have length of 3
          expect(paragraphs, "has 3 paragraphs").to.have.length(3)

          // use second argument to expect(...) to provide clear
          // message with each assertion
          expect(
            paragraphs,
            "has expected text in each paragraph"
          ).to.deep.eq([
            "Some text from first p",
            "More text from second p",
            "And even more text from third p",
          ])
        })
    })

    it("finds element by class name regex", () => {
      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, "text content").to.have.text("Introduction")
        })
    })

    it("can throw any error", () => {
      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(
              `Could not find class "heading-" in ${className}`
            )
          }
        })
    })

    it("matches unknown text between two elements", () => {
      /**
       * Text from the first element.
       * @type {string}
       */
      let text

      /**
       * Normalizes passed text,
       * useful before comparing text with spaces and different capitalization.
       * @param {string} s Text to normalize
       */
      const normalizeText = s => s.replace(/\s/g, "").toLowerCase()

      cy.get(".two-elements")
        .find(".first")
        .then($first => {
          // save text from the first element
          text = normalizeText($first.text())
        })

      cy.get(".two-elements")
        .find(".second")
        .should($div => {
          // we can massage text before comparing
          const secondText = normalizeText($div.text())

          expect(secondText, "second text").to.equal(text)
        })
    })

    it("assert - assert shape of an object", () => {
      const person = {
        name: "Joe",
        age: 20,
      }

      assert.isObject(person, "value is object")
    })

    it("retries the should callback until assertions pass", () => {
      cy.get("#random-number").should($div => {
        const n = parseFloat($div.text())

        expect(n).to.be.gte(1).and.be.lte(10)
      })
    })
  })
})