test: add tests for animationFrameProvider, et al. (#6383)

* test: add provider monkey patch tests

* refactor: use global because Node v11

spec/schedulers/animationFrameProvider-spec.ts

@@ -0,0 +1,34 @@
+/** @prettier */
+import { expect } from 'chai';
+import { animationFrameProvider } from 'rxjs/internal/scheduler/animationFrameProvider';
+
+describe('animationFrameProvider', () => {
+  const originalRequest = global.requestAnimationFrame;
+  const originalCancel = global.cancelAnimationFrame;
+
+  afterEach(() => {
+    global.requestAnimationFrame = originalRequest;
+    global.cancelAnimationFrame = originalCancel;
+  });
+
+  it('should be monkey patchable', () => {
+    let requestCalled = false;
+    let cancelCalled = false;
+
+    global.requestAnimationFrame = () => {
+      requestCalled = true;
+      return 0;
+    };
+    global.cancelAnimationFrame = () => {
+      cancelCalled = true;
+    };
+
+    const handle = animationFrameProvider.requestAnimationFrame(() => {
+      /* noop */
+    });
+    animationFrameProvider.cancelAnimationFrame(handle);
+
+    expect(requestCalled).to.be.true;
+    expect(cancelCalled).to.be.true;
+  });
+});

spec/schedulers/dateTimestampProvider-spec.ts

@@ -0,0 +1,26 @@
+/** @prettier */
+import { expect } from 'chai';
+import { dateTimestampProvider } from 'rxjs/internal/scheduler/dateTimestampProvider';
+
+describe('dateTimestampProvider', () => {
+  const originalDate = global.Date;
+
+  afterEach(() => {
+    global.Date = originalDate;
+  });
+
+  it('should be monkey patchable', () => {
+    let nowCalled = false;
+
+    global.Date = {
+      now() {
+        nowCalled = true;
+        return 0;
+      },
+    } as any;
+
+    dateTimestampProvider.now();
+
+    expect(nowCalled).to.be.true;
+  });
+});

spec/schedulers/intervalProvider-spec.ts

@@ -0,0 +1,34 @@
+/** @prettier */
+import { expect } from 'chai';
+import { intervalProvider } from 'rxjs/internal/scheduler/intervalProvider';
+
+describe('intervalProvider', () => {
+  const originalSet = global.setInterval;
+  const originalClear = global.clearInterval;
+
+  afterEach(() => {
+    global.setInterval = originalSet;
+    global.clearInterval = originalClear;
+  });
+
+  it('should be monkey patchable', () => {
+    let setCalled = false;
+    let clearCalled = false;
+
+    global.setInterval = () => {
+      setCalled = true;
+      return 0 as any;
+    };
+    global.clearInterval = () => {
+      clearCalled = true;
+    };
+
+    const handle = intervalProvider.setInterval(() => {
+      /* noop */
+    });
+    intervalProvider.clearInterval(handle);
+
+    expect(setCalled).to.be.true;
+    expect(clearCalled).to.be.true;
+  });
+});

spec/schedulers/timeoutProvider-spec.ts

@@ -0,0 +1,34 @@
+/** @prettier */
+import { expect } from 'chai';
+import { timeoutProvider } from 'rxjs/internal/scheduler/timeoutProvider';
+
+describe('timeoutProvider', () => {
+  const originalSet = global.setTimeout;
+  const originalClear = global.clearTimeout;
+
+  afterEach(() => {
+    global.setTimeout = originalSet;
+    global.clearTimeout = originalClear;
+  });
+
+  it('should be monkey patchable', () => {
+    let setCalled = false;
+    let clearCalled = false;
+
+    global.setTimeout = (() => {
+      setCalled = true;
+      return 0 as any;
+    }) as any;
+    global.clearTimeout = () => {
+      clearCalled = true;
+    };
+
+    const handle = timeoutProvider.setTimeout(() => {
+      /* noop */
+    });
+    timeoutProvider.clearTimeout(handle);
+
+    expect(setCalled).to.be.true;
+    expect(clearCalled).to.be.true;
+  });
+});