describe("wait() => ", () => {

		let clock: SinonFakeTimers;
		beforeEach(() => {
			clock = useFakeTimers();
		});

		const timeout = 100;

		it(`wait(${timeout}) should wait ${timeout} ms`, (done) => {

			const leSpy = spy();

			wait(timeout).then(() => {
				expect(Date.now()).to.equal(timeout);
				done();
			});
			clock.runAll();

		});

		afterEach(() => {
			clock.restore();
		});
	});

			describe(scenario.description, (): void => {
				let clock: SinonFakeTimers;

				beforeEach((): void => {
					if (scenario.today) {
						const currentYear: number = (new Date()).getFullYear();

						clock = sinon.useFakeTimers(new Date(currentYear, scenario.today.month, scenario.today.day).valueOf());
					}

					episode.status = scenario.status;
					episode.unscheduled = scenario.unscheduled;

					episode.setStatusDate(scenario.statusDate);
				});

				it("should set the status date", (): Chai.Assertion => episode.statusDate.should.equal(scenario.statusDate));
				it("should set the status date display", (): Chai.Assertion => episode.statusDateDisplay.should.equal(scenario.statusDateDisplay));
				it(`should ${"" === scenario.statusWarning ? "not " : ""}highlight the episode with a warning`, (): Chai.Assertion => episode.statusWarning.should.equal(scenario.statusWarning));

				afterEach((): void => {
					if (scenario.today) {
						clock.restore();
					}
				});
			});

 it("can integrate", () => {
   const acceleration = sinkBehavior(1);
   const bIntergrate = integrateFrom(acceleration);
   const integration = at(bIntergrate);
   assert.strictEqual(at(integration), 0);
   clock.tick(2000);
   assert.strictEqual(at(integration), 2000);
   clock.tick(1000);
   assert.strictEqual(at(integration), 3000);
   clock.tick(500);
   acceleration.push(2);
   assert.strictEqual(at(integration), 4000);
 });

 it('releases the lock', async () => {
     await lock.create();
     clock.tick(6000);
     await new Promise(resolve => {
         watcher.once('delete', () => resolve());
     });
 });

 afterEach(async () => {
     clock.restore();
     await nsp
         .delete()
         .key('connection')
         .exec();
 });

				return new Promise(res => {
					setTimeout(() => {
						leSpy(result);
						res(result);
					}, time);
					clock.runAll();
				});

		it("should execute the given promises in a sequence", (done) => {
			const leSpy = spy();
			function doWait(time: number, result: number | {} | PromiseLike<{}>) {
				return new Promise(res => {
					setTimeout(() => {
						leSpy(result);
						res(result);
					}, time);
					clock.runAll();
				});
			}
			// create an array of promise factories that would usually not finish in order
			const factories = [
				() => doWait(300, 1),
				() => doWait(100, 2),
				() => doWait(200, 3),
				() => doWait(50, 4),
			];
			promiseSequence(factories).then(() => {
				leSpy.callCount.should.equal(4);
				leSpy.getCall(0).args[0].should.equal(1);
				leSpy.getCall(1).args[0].should.equal(2);
				leSpy.getCall(2).args[0].should.equal(3);
				leSpy.getCall(3).args[0].should.equal(4);
				done();
			});
			clock.runAll();
		});

 it('should call jobsQueue.register after 10 seconds', async () => {
   const p = inst.onBlockchainReady();
   expect(jobsQueueStub.stubs.register.notCalled).to.be.true;
   clock.tick(10100);
   await p;
   expect(jobsQueueStub.stubs.register.called).to.be.true;
   expect(jobsQueueStub.stubs.register.firstCall.args[0]).to.be.equal('delegatesNextForge');
   expect(jobsQueueStub.stubs.register.firstCall.args[1]).to.be.a('function');
   expect(jobsQueueStub.stubs.register.firstCall.args[2]).to.be.equal(1000);
 });

		it(`wait(${timeout}) should wait ${timeout} ms`, (done) => {

			const leSpy = spy();

			wait(timeout).then(() => {
				expect(Date.now()).to.equal(timeout);
				done();
			});
			clock.runAll();

		});