[1/6] Add behavioural tests and CI

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [22, 24, 26]
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1
+        with:
+          node-version: ${{ matrix.node }}
+          cache: npm
+          registry-url: https://registry.npmjs.org
+      - run: npm ci --ignore-scripts
+      - run: npm test

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+coverage/
+*.tgz

package.json

@@ -3,6 +3,9 @@
   "version": "2.0.0",
   "description": "A simple little asyncronous if check and conditional method",
   "main": "when.js",
+  "scripts": {
+    "test": "node --test test/*.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/thekemkid/when-conditional.git"

test/test-clear.js

@@ -1,21 +1,40 @@
-var when = require('../');
-var someVar = false;
-
-var interval = setInterval(function(){
-  console.log('someVar is ' + someVar);
-  if(someVar === true) clearInterval(interval);
-}, 1000);
-
-var immediate = when(function condition(){
-	return (someVar === true);
-}, function code(){
-	console.log("someVar is now true, and this was only triggered when it became true!");
-});
-
-setTimeout(function(){
-	someVar = true;
-}, 10000);
-
-setTimeout(function(){
-  immediate.clear();
-}, 5000);
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { setImmediate } = require("node:timers/promises");
+const when = require("../");
+
+test("clear stops future checks and is safe to repeat", async (t) => {
+  let checks = 0;
+  let calls = 0;
+  const handle = when(
+    () => {
+      checks++;
+      return false;
+    },
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  handle.clear();
+  handle.clear();
+  await setImmediate();
+
+  assert.equal(checks, 1);
+  assert.equal(calls, 0);
+});
+
+test("setters do not restart a cancelled controller", async (t) => {
+  let calls = 0;
+  const handle = when(
+    () => false,
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  handle.clear();
+  handle.setCondition(() => true);
+  handle.setCode(() => calls++);
+  await setImmediate();
+
+  assert.equal(calls, 0);
+});

test/test-reset.js

@@ -1,28 +1,58 @@
-var when = require('../');
-var someVar = false;
-
-var interval = setInterval(function(){
-  console.log('someVar is ' + someVar);
-  if(someVar === true) clearInterval(interval);
-}, 1000);
-
-var when = when(function condition(){
-	return (someVar === true);
-}, function code(){
-	console.log("someVar is now true, and this was only triggered when it became true!");
-});
-
-setTimeout(function(){
-	someVar = true;
-}, 10000);
-
-setTimeout(function(){
-  when.clear();
-}, 5000);
-
-setTimeout(function(){
-  when.reset();
-  when.setCode(function setNewCode(){
-    console.log("someVar is now true, and this was only triggered when it became true AND after it was reset AND after the 'code' CB was changed! \\0/");
-  })
-}, 8000);
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { setImmediate } = require("node:timers/promises");
+const when = require("../");
+
+test("reset checks a cancelled controller synchronously", (t) => {
+  let ready = false;
+  let calls = 0;
+  const handle = when(
+    () => ready,
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  handle.clear();
+  ready = true;
+  handle.reset();
+
+  assert.equal(calls, 1);
+});
+
+test("reset checks a completed controller synchronously", (t) => {
+  let calls = 0;
+  const handle = when(
+    () => true,
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  assert.equal(calls, 1);
+  handle.reset();
+  assert.equal(calls, 2);
+});
+
+test("a callback can reset the controller after asynchronous success", async (t) => {
+  let ready = false;
+  let calls = 0;
+  const handle = when(
+    () => ready,
+    () => {
+      calls++;
+      if (calls === 1) {
+        ready = false;
+        handle.reset();
+      }
+    },
+  );
+  t.after(() => handle.clear());
+
+  ready = true;
+  await setImmediate();
+  assert.equal(calls, 1);
+  ready = true;
+  await setImmediate();
+  assert.equal(calls, 2);
+  await setImmediate();
+  assert.equal(calls, 2);
+});

test/test.js

@@ -1,18 +1,64 @@
-var when = require('../');
-var someVar = false;
-
-var interval = setInterval(function(){
-  console.log('someVar is ' + someVar);
-  if(someVar === true) clearInterval(interval);
-}, 1000);
-
-var immediate = when(function condition(){
-	return (someVar === true);
-}, function code(){
-	console.log("someVar is now true, and this was only triggered when it became true!");
-});
-
-setTimeout(function(){
-	someVar = true;
-}, 10000);
-
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const { setImmediate } = require("node:timers/promises");
+const when = require("../");
+
+test("calls the callback synchronously when the initial condition is truthy", (t) => {
+  let calls = 0;
+  const handle = when(
+    () => "ready",
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  assert.equal(calls, 1);
+});
+
+test("checks a false condition again and calls the callback once", async (t) => {
+  let ready = false;
+  let calls = 0;
+  const handle = when(
+    () => ready,
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  assert.equal(calls, 0);
+  ready = true;
+  await setImmediate();
+  assert.equal(calls, 1);
+  await setImmediate();
+  assert.equal(calls, 1);
+});
+
+test("uses replacement condition and callback while active", async (t) => {
+  let oldCalls = 0;
+  let newCalls = 0;
+  const handle = when(
+    () => false,
+    () => oldCalls++,
+  );
+  t.after(() => handle.clear());
+
+  handle.setCondition(() => true);
+  handle.setCode(() => newCalls++);
+  await setImmediate();
+
+  assert.equal(oldCalls, 0);
+  assert.equal(newCalls, 1);
+});
+
+test("setters do not restart a completed controller", async (t) => {
+  let calls = 0;
+  const handle = when(
+    () => true,
+    () => calls++,
+  );
+  t.after(() => handle.clear());
+
+  handle.setCondition(() => true);
+  handle.setCode(() => calls++);
+  await setImmediate();
+
+  assert.equal(calls, 1);
+});