Support for `beforeEach` and `afterEach`

Coming from node-tap which is way to slow for my taste I wonder if zora has support for beforeEach and afterEach patterns?

[lorenzofox3]

It is tempting but I consider such hooks anti patterns when in comes to testing, especially for unit testing(so do I for snapshots but it is another story).
Such “features” will probably not make it in zora’s core but sometimes people make me change my mind 😃

However zora is quite simple to extend, you can for example create a decorator:

// beforeEach decorator
// name the function with 'zora_spec_fn' to make sure location is correct
const withBeforeEach = (spec) => function zora_spec_fn(assert) {
    const hooks = [];
    assert.beforeEach = fn => hooks.push(fn);
    const originalTest = assert.test.bind(assert);
    assert.test = function (...args) {

        const [description, specFn, ...rest] = args;

        for (const h of hooks) {
            h();
        }

        // we decorate specFn too, so beforeEach can be used recursively in nested tests as well without calling the decorator
        return originalTest(description, withBeforeEach(specFn), ...rest);
    };

    return spec(assert);
};

to be used as

//src code to test
const sum = (a, b) => a + b

test('some test', withBeforeEach(t => {

    let input = 0;

    t.beforeEach(() => input++);

    t.test(`foo`, t => {
        t.eq(sum(input, 1), 2);
    });

    t.test(`another foo`, t => {
        t.eq(sum(input, 1), 2); // fails (should be 3) to test whether "at" location is correct
    });

    t.test('nested', t => {
        let input = 0;

        t.beforeEach(() => input++);

        t.test(`foo`, t => {
            t.eq(sum(input, 1), 2);
        });

        t.test(`another foo`, t => {
            t.eq(sum(input, 1), 2); // fails (should be 3) to test whether "at" location is correct
        });
    });
}));

A compromise would be to ship such helper functions with zora or within another package

[lorenzofox3]

To be honest I don’t know, I have not dug too much. The hooks I mentioned in this thread are just examples to consider as so, and are not part of zora.

I personally find the usage of such constructs a bad practice (that is why they are not part of the core library) and would rather consider each test independently.

test(`some test`, () => {
    prepare();

    // do some expectations

   teardown()
})

test(`some other test`, () => {
    prepare();

    // do some expectations

   teardown()
})

Which are more explicit and easier to maintain in the long term. I would eventually factorize with a spec decorator to follow DRY principles (like any code) but certainly not use things like beforeEach which create global context and tend to introduce coupling between the tests.

That being said. You are correct: by default zora run all the spec function concurrently. However you can explicitly maintain a shared state or a sequence between sub tests with the async/await control flow like would to for any other JS code:

test(`some test suite`, async (t) => {
   let state = 0;

   //explicitly wait for the test to complete before moving on
  await t.test(`sub test 1`,async (t) => {
       await wait();
       t.eq(state, 0);
       state++;
  });

  await t.test(`sub test 2`,async (t) => {
       await wait();
       t.eq(state, 1);
       state++;
  });

  // etc

})