Is there a way to capture Jasmine assertions?

Question

Is there a way to capture expect failures in Jasmine?

This doesn't work, the exception is not captured.

try {
  expect(1).toBe(3)
} catch (e) {

}

I am looking for something like this TestNG equivalent:

SoftAssert a= new SoftAssert();

a.assertTrue(1==2, "safasfhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh");
a.assertTrue(1==2, "sad");
a.assertTrue(1==2, "test");
a.assertTrue(1==2, "3");

try {

    a.assertAll();

} catch (Throwable  e) {

    Logger logger = Logger.getLogger("");
    logger.log(Level.WARNING, e.toString());

}

Answer 1

Rather than use a string:

assertExpectation("expect(1).toBe(3)");

why not pass a callback, shadowing the global expect with the env's:

assertExpectation(function (expect) {
  expect(1).toBe(3);
};

This means you can have IDE support on the JS code, rather than at runtime when the eval fails, and allows you to have multiple soft expectations (and other code) in one callback. You could implement this like:

function assertExpectation(callback) {
  const env = new jasmine.Env();
  const spec = env.it("", async function () {
    await callback(env.expect);
  });
  return new Promise(function (resolve) {
    spec.resultCallback = function (result) {
      const messages = result.failedExpectations.map(function (e) {
        return e.message;
      });
      resolve(messages);
    }
    env.execute();
  });
}

Note:

1. The env.describe was redundant for a single spec;
2. spec.result seemed to be populated asynchronously in my testing (using Jasmine 3.5.0), so I've added handling for async code throughout;
3. It now handles multiple messages, rather than just the first; and
4. Your code is a good example of how not to use comments, they're either redundant repetition of what the code itself does (e.g. create a variable spec) or out of date with the actual implementation (...along with the stack).

Given the following in a discovered test file with the above implementation:

it("works how I want", async () => {
  const messages = await assertExpectation(function (expect) {
    expect(1).toBe(3);
  });
  console.log(messages);
  expect(1).toBe(1);
});

I get the output

$ npm t

> [email protected] test path/to/soft-expect
> jasmine

Randomized with seed 82972
Started
[ 'Expected 1 to be 3.' ]
.


1 spec, 0 failures
Finished in 0.011 seconds
Randomized with seed 82972 (jasmine --random=true --seed=82972)

Answer 2

Found a workaround for the above issue:

Here I created a separate Jasmine object and calls the expect inside the new Jasmine object and retrieves the error message.

Now I can just pass the Jasmine expectation to assertExpectation as a string and get the message:

 assertExpectation=function (expression) {

  //create a variable spec
  let spec;
  //create a jasmine object
  let env = new jasmine.Env()
  //create describe and spec
  env.describe('desc', function () {
    //assign the spec to the spec variable
    spec = env.it('spec', function (done) {
      //`${env.expect(12).toBe(2)}`
      eval("env." + expression)
    })
  })
  // execute the spec
  env.execute()
  //access the spec and print out the message as error along with the stack to know where exactly this error thrown
  // in our actual spec.
  if (spec.result.failedExpectations[0] !== undefined) {
    return (spec.result.failedExpectations[0].message);
  }
}



describe('Validate expectations', function () {

  it('test', async function () {
    await browser.get("https://www.npmjs.com");    
    console.log(assertExpectation("expect('This sentence ').toContain('nothing')"));    
    await browser.get("https://www.protractortest.org/#/jasmine-upgrade")
  });

});

Output:

Answer 3

If you are trying to find a way so that test continues after assertion fails then it is important to know that the jasmine expectations are kind of "soft" by default.

It means that the test continues to execute even after a failure.