Add expectAssertions option to test

[bompus]

fixes #102

[bompus]

I wasn't sure what to actually name the option, and I'd actually prefer to be able to call t.expectAssertions(2) instead, but that seemed hackish and more complex to implement.

[lorenzofox3]

I wasn't sure what to actually name the option, and I'd actually prefer to be able to call t.expectAssertions(2) instead, but that seemed hackish and more complex to implement.

if you pass it to the assertion object then t.plan() is the convention I think. If you consider it is a "meta" option of the test and pass it as an option like you did, I would rather call it something like exepectedAssertionCount so the idea of "count" can be read.

Semantically it is a bit in between: yes it is a kind of meta option of the test and yes it can be seen as an assertion on the test.
Although you can't model the latter with a regular pure function as you do for the other assertions.

[lorenzofox3]

Thanks for the great effort.

I made some suggestions.

All together, I am not sure it is a worthwhile feature but we can keep on with the discussion in the issue thread

[lorenzofox3]

so expectedAssertionCount would be more appropriate.

I would not set it in the default options, I would simply omit it

[lorenzofox3]

I think that is not a good idea to use the regular equal operator. Creating a specific operator would be better.

[lorenzofox3]

and instead of adding a message in the stream. you can simply add an assertion result at the end of the routine so it will be considered as a regular assertion:

const createAssertionCountResult = ({ expected, actual }) => ({
  pass: expected === actual,
  operator: 'plan',
  expected,
  actual,
  description: 'assertion count should match',
});

export const test = (description, spec, opts = defaultOptions) => {
  const { skip = false, expectAssertions = undefined } = opts;
  /* ... */

  const testRoutine = (async function () {
    try {
      const start = Date.now();
      const result = await specFn();
      executionTime = Date.now() - start;
      // add an extra assertion if needed
      if (expectAssertions) {
        onResult(
          createAssertionCountResult({
            expected: expectAssertions,
            actual: assertions.length,
          })
        );
      }
      return result;
    } catch (e) {
      error = e;
    } finally {
      done = true;
    }
  })();

  return Object.assign(testRoutine, {
    [Symbol.asyncIterator]: async function* () {

     // no need to yield a specific message here 

    /* ... */
    },
  });
};

and if you wish to have add the method on the assertion API instead, you could do something like:

export const test = (description, spec, opts = defaultOptions) => {
  const { skip = false } = opts;
  const assertions = [];
  let executionTime;
  let done = false;
  let error;
  let plan;

  /* ... */

  const specFn = skip
    ? noop
    : function zora_spec_fn() {
        return spec(
          Object.assign(assertFactory({ onResult }), {
          // extend the API here
            plan(value) {
              plan = value;
            },
          })
        );
      };

  const testRoutine = (async function () {
    try {
      const start = Date.now();
      const result = await specFn();
      executionTime = Date.now() - start;
      // add an extra assertion if needed
      if (plan) {
        onResult(
          createAssertionCountResult({
            expected: plan,
            actual: assertions.length,
          })
        );
      }
      return result;
    } catch (e) {
      error = e;
    } finally {
      done = true;
    }
  })();

  return Object.assign(testRoutine, {
    [Symbol.asyncIterator]: async function* () {
     /* ... same here */
    },
  });
};

[bompus]

Upon discussion in #102 , I no longer believe this is necessary. If it comes up again, this will be a good starting poing for implementing the logic though.