test: split up test-runner-mock-timers test

PR-URL: #55506
Reviewed-By: Erick Wendel <erick.workspace@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Claudio Wunder <cwunder@gnome.org>

Author: badkeyy

test/parallel/test-runner-mock-timers-date.js

@@ -0,0 +1,120 @@
+'use strict';
+process.env.NODE_TEST_KNOWN_GLOBALS=0;
+require('../common');
+
+constassert=require('node:assert');
+const{ it, describe }=require('node:test');
+
+describe('Mock Timers Date Test Suite',()=>{
+it('should return the initial UNIX epoch if not specified',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+constdate=newDate();
+assert.strictEqual(date.getTime(),0);
+assert.strictEqual(Date.now(),0);
+});
+
+it('should throw an error if setTime is called without enabling timers',(t)=>{
+assert.throws(
+()=>{
+t.mock.timers.setTime(100);
+},
+{code: 'ERR_INVALID_STATE'}
+);
+});
+
+it('should throw an error if epoch passed to enable is not valid',(t)=>{
+assert.throws(
+()=>{
+t.mock.timers.enable({now: -1});
+},
+{code: 'ERR_INVALID_ARG_VALUE'}
+);
+
+assert.throws(
+()=>{
+t.mock.timers.enable({now: 'string'});
+},
+{code: 'ERR_INVALID_ARG_TYPE'}
+);
+
+assert.throws(
+()=>{
+t.mock.timers.enable({now: NaN});
+},
+{code: 'ERR_INVALID_ARG_VALUE'}
+);
+});
+
+it('should replace the original Date with the mocked one',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+assert.ok(Date.isMock);
+});
+
+it('should return the ticked time when calling Date.now after tick',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+consttime=100;
+t.mock.timers.tick(time);
+assert.strictEqual(Date.now(),time);
+});
+
+it('should return the Date as string when calling it as a function',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+constreturned=Date();
+// Matches the format: 'Mon Jan 01 1970 00:00:00'
+// We don't care about the date, just the format
+assert.ok(/\w{3}\s\w{3}\s\d{1,2}\s\d{2,4}\s\d{1,2}:\d{2}:\d{2}/.test(returned));
+});
+
+it('should return the date with different argument calls',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+assert.strictEqual(newDate(0).getTime(),0);
+assert.strictEqual(newDate(100).getTime(),100);
+assert.strictEqual(newDate('1970-01-01T00:00:00.000Z').getTime(),0);
+assert.strictEqual(newDate(1970,0).getFullYear(),1970);
+assert.strictEqual(newDate(1970,0).getMonth(),0);
+assert.strictEqual(newDate(1970,0,1).getDate(),1);
+assert.strictEqual(newDate(1970,0,1,11).getHours(),11);
+assert.strictEqual(newDate(1970,0,1,11,10).getMinutes(),10);
+assert.strictEqual(newDate(1970,0,1,11,10,45).getSeconds(),45);
+assert.strictEqual(newDate(1970,0,1,11,10,45,898).getMilliseconds(),898);
+assert.strictEqual(newDate(1970,0,1,11,10,45,898).toDateString(),'Thu Jan 01 1970');
+});
+
+it('should return native code when calling Date.toString',(t)=>{
+t.mock.timers.enable({apis: ['Date']});
+assert.strictEqual(Date.toString(),'function Date() { [native code] }');
+});
+
+it('should start with a custom epoch if the second argument is specified',(t)=>{
+t.mock.timers.enable({apis: ['Date'],now: 100});
+constdate1=newDate();
+assert.strictEqual(date1.getTime(),100);
+
+t.mock.timers.reset();
+t.mock.timers.enable({apis: ['Date'],now: newDate(200)});
+constdate2=newDate();
+assert.strictEqual(date2.getTime(),200);
+});
+
+it('should replace epoch if setTime is lesser than now and not tick',(t)=>{
+t.mock.timers.enable();
+constfn=t.mock.fn();
+constid=setTimeout(fn,1000);
+t.mock.timers.setTime(800);
+assert.strictEqual(Date.now(),800);
+t.mock.timers.setTime(500);
+assert.strictEqual(Date.now(),500);
+assert.strictEqual(fn.mock.callCount(),0);
+clearTimeout(id);
+});
+
+it('should not tick time when setTime is called',(t)=>{
+t.mock.timers.enable();
+constfn=t.mock.fn();
+constid=setTimeout(fn,1000);
+t.mock.timers.setTime(1200);
+assert.strictEqual(Date.now(),1200);
+assert.strictEqual(fn.mock.callCount(),0);
+clearTimeout(id);
+});
+});

test/parallel/test-runner-mock-timers-scheduler.js

@@ -0,0 +1,124 @@
+'use strict';
+process.env.NODE_TEST_KNOWN_GLOBALS=0;
+constcommon=require('../common');
+
+constassert=require('node:assert');
+const{ it, describe }=require('node:test');
+constnodeTimersPromises=require('node:timers/promises');
+
+describe('Mock Timers Scheduler Test Suite',()=>{
+it('should advance in time and trigger timers when calling the .tick function',(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+constnow=Date.now();
+constdurationAtMost=100;
+
+constp=nodeTimersPromises.scheduler.wait(4000);
+t.mock.timers.tick(4000);
+
+returnp.then(common.mustCall((result)=>{
+assert.strictEqual(result,undefined);
+assert.ok(
+Date.now()-now<durationAtMost,
+`time should be advanced less than the ${durationAtMost}ms`
+);
+}));
+});
+
+it('should advance in time and trigger timers when calling the .tick function multiple times',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+
+constfn=t.mock.fn();
+
+nodeTimersPromises.scheduler.wait(9999).then(fn);
+
+t.mock.timers.tick(8999);
+assert.strictEqual(fn.mock.callCount(),0);
+t.mock.timers.tick(500);
+
+awaitnodeTimersPromises.setImmediate();
+
+assert.strictEqual(fn.mock.callCount(),0);
+t.mock.timers.tick(500);
+
+awaitnodeTimersPromises.setImmediate();
+assert.strictEqual(fn.mock.callCount(),1);
+});
+
+it('should work with the same params as the original timers/promises/scheduler.wait',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+constcontroller=newAbortController();
+constp=nodeTimersPromises.scheduler.wait(2000,{
+ref: true,
+signal: controller.signal,
+});
+
+t.mock.timers.tick(1000);
+t.mock.timers.tick(500);
+t.mock.timers.tick(500);
+t.mock.timers.tick(500);
+
+constresult=awaitp;
+assert.strictEqual(result,undefined);
+});
+
+it('should abort operation if timers/promises/scheduler.wait received an aborted signal',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+constcontroller=newAbortController();
+constp=nodeTimersPromises.scheduler.wait(2000,{
+ref: true,
+signal: controller.signal,
+});
+
+t.mock.timers.tick(1000);
+controller.abort();
+t.mock.timers.tick(500);
+t.mock.timers.tick(500);
+t.mock.timers.tick(500);
+
+awaitassert.rejects(()=>p,{
+name: 'AbortError',
+});
+});
+it('should abort operation even if the .tick was not called',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+constcontroller=newAbortController();
+constp=nodeTimersPromises.scheduler.wait(2000,{
+ref: true,
+signal: controller.signal,
+});
+
+controller.abort();
+
+awaitassert.rejects(()=>p,{
+name: 'AbortError',
+});
+});
+
+it('should abort operation when .abort is called before calling setInterval',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+constcontroller=newAbortController();
+controller.abort();
+constp=nodeTimersPromises.scheduler.wait(2000,{
+ref: true,
+signal: controller.signal,
+});
+
+awaitassert.rejects(()=>p,{
+name: 'AbortError',
+});
+});
+
+it('should reject given an an invalid signal instance',async(t)=>{
+t.mock.timers.enable({apis: ['scheduler.wait']});
+constp=nodeTimersPromises.scheduler.wait(2000,{
+ref: true,
+signal: {},
+});
+
+awaitassert.rejects(()=>p,{
+name: 'TypeError',
+code: 'ERR_INVALID_ARG_TYPE',
+});
+});
+});