How to use removeMeAndAbove method in Cypress

You can return false to break early, see docs.

Return early
You can stop the .each() loop early by returning false in the callback function.

Tested with cypress fiddle

const selectMySection = {
  html: `
    <div class="myclass">
      <span id="myid">
        <p>child of span1</p>
        <p>child of span2</p>
        span text - find this
      </span>
    </div>
    <div class="myclass">
      <span id="myid">
        <p>child of span3</p>
        <p>child of span4</p>
        span text - ignore this
      </span>
    </div>
  `,
  test: `
    cy.get('div.myclass span#myid')
      .each(($span, i) => {
        console.log('processing span #', i); // only logs 'processing span # 0'
        const text = Cypress.$($span).text()
        if (text.includes('span text - find this')) {
          cy.wrap($span)
            .parent('div.myclass')  // move to parent
            .as('mySection')
          return false;
        }
      })

    cy.get('@mySection')
      .then(x => console.log(x))
  `
}
it('test selectMySection', () => {
  cy.runExample(selectMySection)
})

An alternative to looping is to use .contains('my text') to target the text you want.
Note that .contains() does a partial match, so you can ignore child texts.

cy.get('div.myclass span#myid')
  .contains('span text - find this')
  .as('mySection')

To find the title of h1, you could try the below code. Inside the equal bracket, you should give the 'real title' name to verify in the assertion part;

cy.get('#d2>h1').invoke('text')
      .then((text)=>{
        const title = text;
        expect(title).to.equal("typeherethedata.title");        
      })

or

cy.get('#txt1').invoke('text')
          .then((text)=>{
            const title = text;
            expect(title).to.equal("typeherethedata.title");        
          })

EDIT 2: This solution was written for Cypress ~3.6.0 or thereabouts so it's possible that newer versions of Cypress work very differently internally, even if you fix some superficial incompatibilities of this code.

EDIT: often someone suggests using Promise.all, which is not a correct solution. Cypress chainer objects aren't Promises/A+-compatible, they simply appear to be promises because they implement .then interface. That's why Promise.all is able to consume an array of chainer objects, but that's it. The resolution values passed to Promise.all().then callback is not going to be what you expect (see https://github.com/cypress-io/cypress/issues/915).

You can use a helper I've suggested in a similar answer:

// put this in cypress/support/index.js

const chainStart = Symbol();
cy.all = function ( ...commands ) {
    const _           = Cypress._;
    const chain       = cy.wrap(null, { log: false });
    const stopCommand = _.find( cy.queue.commands, {
        attributes: { chainerId: chain.chainerId }
    });
    const startCommand = _.find( cy.queue.commands, {
        attributes: { chainerId: commands[0].chainerId }
    });
    const p = chain.then(() => {
        return _( commands )
            .map( cmd => {
                return cmd[chainStart]
                    ? cmd[chainStart].attributes
                    : _.find( cy.queue.commands, {
                        attributes: { chainerId: cmd.chainerId }
                    }).attributes;
            })
            .concat(stopCommand.attributes)
            .slice(1)
            .flatMap( cmd => {
                return cmd.prev.get('subject');
            })
            .value();
    });
    p[chainStart] = startCommand;
    return p;
}

usage:

it('test', () => {
    const urls = [
        'https://en.wikipediaaa.org',
        'https://en.wikipedia.org'
    ];

    cy.all(
        ...urls.map(url => cy.request(url))
    ).then(responses => {
        responses.forEach( resp => {
            expect(resp.status).to.eq(200);
        });
    });
});

That being said, you can also do this:

const urls = [
    'https://en.wikipediaaa.org',
    'https://en.wikipedia.org'
];

let passes = 0;

urls.forEach( url => {
    cy.request(url).then( resp => {
        if ( resp.status === 200 ) passes++;
    });
});

cy.then(() => {
    expect(passes).to.eq(urls.length);
});

The cy.all helper atop is really useful if you want to access the results without having to keep around globals and accessing them from a cy.then() callback --- but like I've shown in the last example, everything can be worked around using just vanilla cypress.

Or, if you don't need responses at all, you can simply do:

const urls = [
    'https://en.wikipediaaa.org',
    'https://en.wikipedia.org'
];
urls.forEach( url => {
    cy.request(url).its('status').should('eq', 200);
});

There is a built-in DOM method document.execCommand.
In case of an extension, use this code in the content script.

// some.selector may be `input` or `[contenteditable]` for richly formatted inputs
const el = document.querySelector('some.selector');
el.focus();
document.execCommand('insertText', false, 'new text');
el.dispatchEvent(new Event('change', {bubbles: true})); // usually not needed

It imitates physical user input into the currently focused DOM element so all the necessary events will be fired (like beforeinput, input) with isTrusted field set to true. On some pages the change event should be additionally dispatched as shown above.

You may want to select the current text to replace it entirely instead of appending:

replaceValue('some.selector', 'new text');

function replaceValue(selector, value) {
  const el = document.querySelector(selector);
  if (el) {
    el.focus();
    el.select();
    if (!document.execCommand('insertText', false, value)) {
      // Fallback for Firefox: just replace the value
      el.value = 'new text';
    }
    el.dispatchEvent(new Event('change', {bubbles: true})); // usually not needed
  }
  return el;
}

Note that despite execCommand being marked as obsolete in 2020, it'll work in the foreseeable future because a new editing API specification is not finished yet, and knowing how slow such things usually move it may take another 5-20 years.

I would say you are on the right track, but .contains(/^Tier2_Forest/) fails because the text is not at the beginning of the string, there is white space preceding it.

Just try .contains(/Tier2_Forest/)

or more precisely .contains(/\s*Tier2_Forest/)

where \s* matches any whitespace character (equal to [\r\n\t\f\v ])

Check it out in https://regex101.com

The recommendation is to change it to:

.then((res) => {
    if (res.status != 200) {
        cy.log(JSON.stringify(res));
        return; // exit function, no need for an `else` after this
    }
    expect(res.body.id).to.eq(vehicleIdBuyNow);
    expect(res.body.auctionStatus).contains("finished");
    expect(res.body.price).to.be.equal(minPrice);
    expect(res.body.winningBidPlatformId).contains(platformIdBuyNow);
    expect(true).to.be.true;

To be able to use cy.server() & cy.route() with fetch requests, you need to do as stated here: https://stackoverflow.com/a/49088084/9947826

You can use Object.values in js to retrieve values from your object

Let's say you need to extract the value of the 3rd column, so your code will look like,

cy.task('DBQuery', query).then(function (recordset) {
    var rec = recordset
    const results = Object.values(rec[0])
    // results[index of the column] will output the results
    cy.log(results[3])
})

We can do a small modification to make your task easier,

cy.task('DBQuery', query).then(function (recordset) {
    var rec = recordset
    const Values = Object.values(rec[0]);
    const keys = Object.keys(rec[0]);
    let result = {};
    let index = 0;
    keys.forEach(key => {
        result[keys[index]] = Values[index];
        i++
    })
     //result.firstName will give you your results
     cy.log(result.firstName);
})

In this way, we are generating key-value pairs having the key as the column name. So you can use the column name to find the value.

Hope this helps.

cheers.

Using a similar strategy to Jennifer's answer, you can use invoke to replace the text value.

cy.get('.total-month')
  .invoke('text')
  .invoke('replace', 'NNSP', ' ')
  .should('contains', '+123 456,33');

The tl;dr is that your character is interpreted as NNSP. Replacing that with a traditional whitespace character should solve your problem.