RequestLogger 'contains' method expected behavior

Question

Working on an end-to-end test suite with the TestCafe framework.

I'm trying to implement assertions on requests URL parameters, and requests firing/not firing depending on frontend use cases.

The kind of components under test are a table Filter panel with a lot of filters.

So i test each filter one by one and make assertions on the requests parameters formats depending on each filter type.

In the end i'd like to check that when clearing filters there is no request firing with any of the filters parameters.

In my understanding, if I do not call the "clear" method of the logger before doing this last assertion, this should not pass. But the test is actually green.

It seems to me like I'm not correctly understanding the behavior of the logger. contains assertion mechanism? Does it always check the latest request only? Or does it check against any of the logged requests?

Here is my test code :

test('Transactions Base Filters', async (t) => {
  // amount filter
  await t.typeText(filters.grossAmountMin, '10')
    .expect(filters.activeFilter.count).eql(1)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('grossAmount=10__value') > 0
    ))).ok()
    .typeText(filters.grossAmountMax, '5')
    .expect(filters.grossAmountMin.getReact(({ props: { error } }) => error)).ok()
    .expect(filters.grossAmountMax.getReact(({ props: { error } }) => error)).ok()
    // check invalid input does not fire a request
    .expect(logger.count(r => r.request.url.indexOf('grossAmount=10__value__5') > 0)).eql(0)
    .typeText(filters.grossAmountMax, '00')
    .expect(filters.grossAmountMin.getReact(({ props: { error } }) => error)).notOk()
    .expect(filters.grossAmountMax.getReact(({ props: { error } }) => error)).notOk()
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('grossAmount=10__value__500') > 0
    ))).ok();

  // orderId filter
  await t.typeText(filters.orderId, '8E')
    .expect(filters.activeFilter.count).eql(2)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('orderId=*8E*') > 0
    ))).ok()
    .click(filters.orderId)
    .pressKey('ctrl+a delete')
    .expect(filters.activeFilter.count).eql(1);

  // email filter
  await t.typeText(filters.customerEmail, 'fvrecord')
    .expect(filters.activeFilter.count).eql(2)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('customerEmail=*fvrecord*') > 0
    ))).ok()
    .click(filters.customerEmail)
    .pressKey('ctrl+a delete')
    .expect(filters.activeFilter.count).eql(1);

  // status filter
  await t.click(filters.status)
    .click(filters.statusMenuItem('VALIDATED'))
    .expect(filters.activeFilter.count).eql(2)
    .expect(filters.status.getReact(({ props: { value } }) => value.length)).eql(1)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('status=VALIDATED') > 0
    ))).ok()
    .click(filters.status)
    .click(filters.statusMenuItem('REFUSED'))
    .expect(filters.status.getReact(({ props: { value } }) => value.length)).eql(2)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('status=VALIDATED|REFUSED') > 0
    ))).ok()
    .click(filters.status)
    .click(filters.statusMenuItem('VALIDATED'))
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('status=VALIDATED') > 0
    ))).ok()
    .click(filters.status)
    .click(filters.statusMenuItem('REFUSED'))
    .expect(filters.status.getReact(({ props: { value } }) => value.length)).eql(0)
    .expect(filters.activeFilter.count).eql(1);

  // transactionType filter
  await t.click(filters.type)
    .click(filters.statusMenuItem('DEBIT'))
    .expect(filters.activeFilter.count).eql(2)
    .expect(filters.type.getReact(({ props: { value } }) => value.length)).eql(1)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('type=DEBIT') > 0
    ))).ok();

  // reset all
  // logger.clear();
  await t.click(filters.resetButton)
    .expect(filters.activeFilter.count).eql(0)
    .expect(logger.contains(r => (
      r.response.statusCode === 200
      && r.request.url.indexOf('grossAmount=') < 0
      && r.request.url.indexOf('orderId=') < 0
      && r.request.url.indexOf('customerEmail=') < 0
      && r.request.url.indexOf('status=') < 0
      && r.request.url.indexOf('type=') < 0
    ))).ok();
});

Answer 1

You can check that there are no filter parameters in this final request using logger and Node.js modules (url, querystirng). For example:

.expect(logger.contains (r => r.response.statusCode == 200 && checkParameters(r.request.url)))

function checkParameters(url) {
   var parsedUrl = url.parse(url):
   var parsedParameters = querystring.parse(url.path);

return parsedParameters.param1 === '' && parsedParamters.param2 == '' ...

}