From 4363b415f104f82bdcee710d83138f393235fec3 Mon Sep 17 00:00:00 2001
From: Clement Denis <le.mikmac@gmail.com>
Date: Fri, 11 Sep 2020 14:12:10 +0200
Subject: [PATCH] js: replace setInterval with sync loop for precision

---
 js/tests/debounce_test.js | 45 +++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 16 deletions(-)

diff --git a/js/tests/debounce_test.js b/js/tests/debounce_test.js
index 6c66e2456..caf8ff7f2 100644
--- a/js/tests/debounce_test.js
+++ b/js/tests/debounce_test.js
@@ -3,26 +3,39 @@ const t = (f) => tests.push(f)
 
 const add = (arr, el) => arr.push(el)
 
+// async setInterval is not precise enough so I made this synchronous one
+const setIntervalSync = (fn, delay, limit) => {
+  let run = true
+  let count = 1
+  const start = Date.now()
+  while (run) {
+    const tick = Date.now()
+    const elapsed = tick - start
+    if (elapsed > count * delay) {
+      console.log({ elapsed, count })
+      fn()
+      count++
+      if (count >= limit) return
+    }
+  }
+}
+
 // it uses the array to better test the leading and trailing edge of the time limit
 // so if the leading edge is true it will execute the callback
 // if the trailing edge is true it will execute the callback before returning the array
-const run = (callback, { delay, count }) =>
-  new Promise((r) => {
-    const arr = []
-    const inter = setInterval(() => callback(arr, 1), delay)
-    setTimeout(() => {
-      clearInterval(inter)
-      r(arr.length)
-    }, delay * count)
-  })
+const run = (callback, { delay, count }) => {
+  const arr = []
+  setIntervalSync(() => callback(arr, 1), delay, count)
+  return arr.length
+}
 
 t(async ({ eq }) =>
   // test with debounce wait limit inferior to wait time call (how much time we wait to the function be called again)
   // it works concurrently
   eq(
     await Promise.all([
-      run(debounce(add, 50), { delay: 100, count: 5 }),
-      run(debounce(add, 20), { delay: 50, count: 10 }),
+      run(debounce(add, 5), { delay: 10, count: 5 }),
+      run(debounce(add, 2), { delay: 5, count: 10 }),
     ]),
     [4, 9]
   )
@@ -30,15 +43,15 @@ t(async ({ eq }) =>
 t(async ({ eq }) =>
   // testing with wait limit superior to wait time call
   // execution on the trailing edge, after wait limit has elapsed
-  eq(await run(debounce(add, 100), { delay: 50, count: 5 }), 0)
+  eq(await run(debounce(add, 10), { delay: 5, count: 5 }), 0)
 )
 
 t(async ({ eq }) =>
   // it works concurrently
   eq(
     await Promise.all([
-      run(opDebounce(add, 40), { delay: 20, count: 5 }),
-      run(opDebounce(add, 40), { delay: 20, count: 2 }),
+      run(opDebounce(add, 4), { delay: 2, count: 5 }),
+      run(opDebounce(add, 4), { delay: 2, count: 2 }),
     ]),
     [0, 0]
   )
@@ -49,8 +62,8 @@ t(async ({ eq }) =>
   // it works concurrently
   eq(
     await Promise.all([
-      run(opDebounce(add, 200, { leading: true }), { delay: 70, count: 3 }),
-      run(opDebounce(add, 100, { leading: true }), { delay: 140, count: 3 }),
+      run(opDebounce(add, 20, { leading: true }), { delay: 7, count: 3 }),
+      run(opDebounce(add, 10, { leading: true }), { delay: 14, count: 3 }),
     ]),
     [1, 2]
   )