Merge pull request #5 from parzh/chore/add-test-for-refresh

Improve tests

Author: parzhitsky

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "recursive-timeout",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "author": "Dmytro Parzhytskyi <parzhitsky@gmail.com> (https://parzh.com)",
   "description": "A simple solution to a classic problem: setInterval implemented as recursive setTimeout calls.",
   "license": "MIT",

package.json

@@ -10,9 +10,9 @@ describe(clearRecursiveTimeout, () => {
   })
 
   it('should clear the scheduled timeout', async () => {
-    const timeout = createRecursiveTimeout(callback, 100)
+    const recursive = createRecursiveTimeout(callback, 100)
 
-    clearRecursiveTimeout(timeout)
+    clearRecursiveTimeout(recursive)
 
     await delay(150)
 

src/with-callback/clear-recursive-timeout.spec.ts

@@ -1,5 +1,5 @@
 import type { RecursiveTimeout, ArgsShape } from './recursive-timeout'
 
-export function clearRecursiveTimeout(timeout: RecursiveTimeout<ArgsShape>): void {
-  timeout.clear()
+export function clearRecursiveTimeout(recursive: RecursiveTimeout<ArgsShape>): void {
+  recursive.clear()
 }

src/with-callback/clear-recursive-timeout.ts

@@ -4,11 +4,11 @@ import { RecursiveTimeout } from './recursive-timeout'
 
 describe(createRecursiveTimeout, () => {
   it('should create an instance of RecursiveTimeout class', () => {
-    const timeout = createRecursiveTimeout(() => {}, 10_000)
+    const recursive = createRecursiveTimeout(() => {}, 10_000)
 
-    expect(timeout).toBeInstanceOf(RecursiveTimeout)
+    expect(recursive).toBeInstanceOf(RecursiveTimeout)
 
-    timeout.clear()
+    recursive.clear()
   })
 
   it('should schedule next call only after the current call is finished', async () => {
@@ -21,11 +21,11 @@ describe(createRecursiveTimeout, () => {
       return Date.now()
     })
 
-    const timeout = createRecursiveTimeout(longJob, 50)
+    const recursive = createRecursiveTimeout(longJob, 50)
 
     await delay(300) // I can't use fake timers, unfortunately
 
-    timeout.clear()
+    recursive.clear()
 
     expect(longJob).toHaveBeenCalledTimes(2)
 

src/with-callback/create-recursive-timeout.spec.ts

@@ -13,12 +13,44 @@ describe(RecursiveTimeout, () => {
     ['clearInterval', clearInterval],
     ['clearTimeout', clearTimeout],
   ])('should be cancellable with %s', async (clearName, clear) => {
-    const timeout = createRecursiveTimeout(callback, 100)
+    const recursive = createRecursiveTimeout(callback, 100)
 
-    clear(timeout)
+    clear(recursive)
 
     await delay(150)
 
     expect(callback).not.toHaveBeenCalled()
   })
+
+  it('should allow delaying the call by refreshing the timeout instance', async () => {
+    const recursive = createRecursiveTimeout(callback, 200)
+
+    for (let i = 0; i < 3; i += 1) {
+      await delay(100)
+
+      recursive.refresh()
+    }
+
+    expect(callback).not.toHaveBeenCalled()
+
+    await delay(200 + 10)
+
+    clearTimeout(recursive)
+
+    expect(callback).toHaveBeenCalledTimes(1)
+  })
+
+  it('should show whether it is ref-ed or not', () => {
+    const recursive = createRecursiveTimeout(callback, 100)
+
+    expect(recursive.hasRef()).toBe(true)
+
+    for (const [methodName, hasRefExpected] of [['unref', false], ['ref', true]] as const) {
+      recursive[methodName]()
+
+      expect(recursive.hasRef()).toBe(hasRefExpected)
+    }
+
+    recursive.unref() // let it all go
+  })
 })

src/with-callback/recursive-timeout.spec.ts

@@ -29,6 +29,7 @@ export class RecursiveTimeout<Args extends ArgsShape> implements NodeJS.Timeout
       // we're naming the tick function the same as the original callback
       [this.callback.name]: () => {
         this.callback(...this.args)
+        this.clear()
         this.setTimer(tick)
       },
     }

src/with-callback/recursive-timeout.ts

@@ -1,5 +1,5 @@
 import type { RecursiveTimeout, ArgsShape } from './recursive-timeout'
 
-export function clearRecursiveTimeout(timeout: RecursiveTimeout<ArgsShape>): void {
-  timeout.clear()
+export function clearRecursiveTimeout(recursive: RecursiveTimeout<ArgsShape>): void {
+  recursive.clear()
 }