Question: global before/after support

[sberserker]

Does this lib support global before and after hooks?
In regular mocha if before and after are outside the describe block they becoming global hooks means they run before and after all the tests in all the suites.
This seems doesn't work for this library. Is there anyway to achieve this behavior? I need to setup tokens in before hook to use them in all the test cases.

[1999]

Yes, you can do this with --require mocha option. Files which you specify in this option will be executed before parallel tests.

[sberserker]

In general it'll work but I'm not sure how to achieve the following.
I'm using mocha for api testing so i have to supply oauth token with every api call.

in the global before I can asynchronously get the token and set global request defaults

before(function(){  
	return getOauthToken().then(function(){
		setRequestDefaults();
	});
})

with mocha --require i'll have to resolve the token in every describe file. Is there any better option to achieve the former behavior? essentially get the tests wait on async call complete to be able to use global values

[1999]

If I understand you correct, this is what you need:

CLI: mocha-parallel-tests --require base.js test/
base.js

before(function(){  
	return getOauthToken().then(function(token){
		global.token = token;
	});
});

test/foo.js

describe('suite', () => {
const req = request.defaults({ headers: { Authorization: Bearer ${global.token} } });

it('case', () => {
req(...);
});
})

[sberserker]

That's right.
The only issue seems like you cannot call any of mocha before, it, describe in require(d) files.
Tried to trick it but didn't work. Either getting before is undefined or before is not a function
var Mocha = require('mocha');
var before = require('mocha').before.

[1999]

Gotcha. Double checked that, mocha doesn't wait until --require'd file finishes its execution, so in your case the quick way to get things done is this hack:

// base.js
(async () => {
  global.token = await getOauthToken();
})();

// test.js
let req;

before(async () => {
  const authToken = await global.token;
  req = request.defaults({ headers: { Authorization: Bearer ${authToken} } });
});

describe('suite', () => {
  it('case', () => {
    req(...)
  })
});

[sberserker]

That will work. The only inconvenience we'll have to have before for each describe but seems like there is no any other easy way.

What about global after? Any suggestions how to achieve that?

[1999]

Nope, no easy way for now. I think it would be better to leave this issue open so that we can think of a better solution when we have time for that.

[gingur]

https://mochajs.org/#delayed-root-suite ?

[ghost]

So... I have the distinct impression that if you have 2 test files, your --require file gets run twice. Is that intentional? If so, any way to avoid it?

[1999]

@erwinw I'm not 100% sure but this sounds like an expected behaviour of mocha-parallel-tests v2 because it runs each file in parallel. We can run this --require'd file inside the main process for sure but in this case there's no way to pass the results to forked test processes.

[ghost]

Thanks for the reply, @1999 . It’s a bit unfortunate since it’s leaves only hacky solutions; I’m trying to share some info between the processes and I guess the only thing we might have is the ID of the parent process (process.ppid — haven’t tested if that is correct in this case, and a file on disk based on this ID. Cleanup after running is a whole different kettle of fish...

[1999]

@erwinw right. Maybe that's a good area for mocha-parallel-tests improvement - some kind of lock/release API so that the processes can share some state between them. Right now using a file as a lock is probably the only way I can think of to make it work.

[ghost]

Well, you have the ipc channel you can use, @1999?

[ghost]

What I'm thinking is that a mechanism to run some code exclusively before all tests are run, and after all test are run.

Maybe you could have an event emitter exposed on the mocha-parallel-tests module. The trick would be to decide which of the instances would run the 'parallel-before' and 'parallel-after'? I don't know if Mocha has any way of allowing the definition of these -- otherwise --require could be the mechanism to define the user's 'parallel-before' and 'parallel-after' event handler. I guess the runner could evaluate those files, and if the parallel-before handler is defined, ask the main process whether to run it or not, where the main process, if it's the first, could say 'yes', and if it's not, either continue (if the 'parallel-before' has already finished) or wait until the 'parallel-before' has finished. A similar thing could happen at the end.