clever-queue 0.2.4 → 0.4.1

package/src/tasks/index.ts

@@ -3,7 +3,7 @@
 import * as _ from "../helpers";
 import { Options, Statistics, ErrorsList, FunctionToExecute } from "./interfaces";
 
-type Status = "unknown" | "initialiazing" | "queued" | "running" | "runned" | "exception" | "destroying";
+type Status = "unknown" | "initializing" | "queued" | "running" | "completed" | "exception" | "destroying";
 
 const defaultOptions: Options = {
   logFunction: undefined,
@@ -33,7 +33,7 @@ class Task {
   }
 
   constructor(function_: FunctionToExecute, opt: Options) {
-    this.status = "initialiazing";
+    this.status = "initializing";
     this.options = this.#checkOptionsConsistancy({ ...defaultOptions, ...opt });
     if (!this.options.id) this.options.id = _.Id.generate();
     if (typeof function_ !== "function") throw new _.Errors.CQError(ErrorsList.FunctionIsNotAFunction);
@@ -46,11 +46,15 @@ class Task {
       this.status = "running";
       try {
         this.result = await this.#functionToExecute();
-        this.status = "runned";
+        this.status = "completed";
         this.resolver(this.result);
       } catch (error) {
         this.status = "exception";
-        this.rejecter(new _.Errors.CQError(ErrorsList.FunctionRaisedAnHundledException));
+        if (error instanceof Error) {
+          this.rejecter(error);
+        } else {
+          this.rejecter(new _.Errors.CQError(ErrorsList.FunctionRaisedAnHundledException));
+        }
       }
     };
   }

package/test/behavior/scheduler.mjs

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+function createTrackedTask(engine, label) {
+  return engine.createTask(() => label, { id: label });
+}
+
+async function dequeueLabels(engine, count, priority = cleverQueue.queues.Priorities.BestEffort) {
+  const labels = [];
+  for (let index = 0; index < count; index += 1) {
+    const task = await engine.getNextTask(priority);
+    assert.ok(task, `expected task ${index + 1} to be available`);
+    labels.push(task.options.id);
+  }
+
+  const finalTask = await engine.getNextTask(priority);
+  assert.equal(finalTask, undefined);
+  return labels;
+}
+
+describe("scheduler behavior", () => {
+  it("prefers higher-priority queues before lower-priority queues", async () => {
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const bestEffortQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.BestEffort, weight: 10 });
+    const standardQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 10 });
+    const absoluteQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Absolute, weight: 10 });
+
+    bestEffortQueue.enqueue(createTrackedTask(engine, "best-effort"));
+    standardQueue.enqueue(createTrackedTask(engine, "standard"));
+    absoluteQueue.enqueue(createTrackedTask(engine, "absolute"));
+
+    engine.start();
+    const labels = await dequeueLabels(engine, 3);
+    assert.deepEqual(labels, ["absolute", "standard", "best-effort"]);
+    engine.stop();
+  });
+
+  it("distributes work proportionally between queues with different weights", async () => {
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const heavyQueue = engine.createQueue({ id: "heavy", priority: cleverQueue.queues.Priorities.Standard, weight: 2 });
+    const lightQueue = engine.createQueue({ id: "light", priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    for (let index = 0; index < 4; index += 1) heavyQueue.enqueue(createTrackedTask(engine, `heavy-${index}`));
+    for (let index = 0; index < 2; index += 1) lightQueue.enqueue(createTrackedTask(engine, `light-${index}`));
+
+    engine.start();
+    const labels = await dequeueLabels(engine, 6);
+    assert.deepEqual(labels, ["heavy-0", "heavy-1", "light-0", "heavy-2", "heavy-3", "light-1"]);
+    engine.stop();
+  });
+
+  it("starts multiple tasks concurrently when multiple runners are available", async () => {
+    const engine = cleverQueue.createEngine({ bestEffortRunners: 2 });
+    const queue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    let started = 0;
+    let release;
+    const releasePromise = new Promise((resolve) => {
+      release = resolve;
+    });
+    const events = [];
+
+    const createBlockingTask = (label) =>
+      engine.createTask(async () => {
+        started += 1;
+        events.push(`${label}:start:${started}`);
+        await releasePromise;
+        events.push(`${label}:finish`);
+        return label;
+      }, { id: label });
+
+    const first = queue.enqueue(createBlockingTask("first"));
+    const second = queue.enqueue(createBlockingTask("second"));
+
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("timed out waiting for both runners to start tasks")), 250);
+      const poll = () => {
+        if (started === 2) {
+          clearTimeout(timeout);
+          resolve();
+          return;
+        }
+
+        setTimeout(poll, 5);
+      };
+
+      poll();
+    });
+
+    release();
+    assert.deepEqual(await Promise.all([first, second]), ["first", "second"]);
+    assert.deepEqual(events.slice(0, 2), ["first:start:1", "second:start:2"]);
+    engine.stop();
+  });
+
+  it("keeps priority dominance while still applying weighted fairness within a priority", async () => {
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const absoluteQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Absolute, weight: 1 });
+    const standardHeavyQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 2 });
+    const standardLightQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    absoluteQueue.enqueue(createTrackedTask(engine, "absolute-0"));
+    absoluteQueue.enqueue(createTrackedTask(engine, "absolute-1"));
+    for (let index = 0; index < 4; index += 1) standardHeavyQueue.enqueue(createTrackedTask(engine, `standard-heavy-${index}`));
+    for (let index = 0; index < 2; index += 1) standardLightQueue.enqueue(createTrackedTask(engine, `standard-light-${index}`));
+
+    engine.start();
+    const labels = await dequeueLabels(engine, 8);
+
+    assert.deepEqual(labels, [
+      "absolute-0",
+      "absolute-1",
+      "standard-heavy-0",
+      "standard-heavy-1",
+      "standard-light-0",
+      "standard-heavy-2",
+      "standard-heavy-3",
+      "standard-light-1",
+    ]);
+    engine.stop();
+  });
+});

package/test/issues/00001.mjs

@@ -8,28 +8,30 @@ const engineOptions = {
   logFunction: undefined,
 };
 
-const task = async (string_) => {
-  // console.log(string_, "Start", new Date());
-  await new Promise((resolve, reject) => setTimeout(reject(string_), 2000));
-  // console.log(string_, "End", new Date());
-  return string_;
+
+const task = async (customErrorMessage) => {
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  throw customErrorMessage; // this is the not tight way to throw an exception, but it is to test the case where the function raises an exception that is not an instance of Error
 };
 
 describe("Issue #1", () => {
-  it("Exception if function passed raised an exception", () => {
+  it("Exception if function passed raised an exception that is not an instance of Error", async () => {
     const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
-    assert.rejects(
-      async () => {
-        const myTask = engine.createTask(() => task("taskMustFail"), {});
-        await queue1.enqueue(myTask);
-      },
-      { name: "FunctionRaisedAnHundledException" },
-    );
-    engine.stop();
+    try {
+      await assert.rejects(
+        async () => {
+          const myTask = engine.createTask(() => task("a message exception that is not an instance of Error"), {});
+          await queue1.enqueue(myTask);
+        },
+        { name: cleverQueue.tasks.ErrorsList.FunctionRaisedAnHundledException.name },
+      );
+    } finally {
+      engine.stop();
+    }
   });
 });

package/test/issues/00002.mjs

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+const engineOptions = {
+  bestEffortRunners: 1,
+  logFunction: undefined,
+};
+
+
+const task = async (customErrorMessage) => {
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+  if (customErrorMessage) throw new Error(customErrorMessage); // this is the not tight way to throw an exception, but it is to test the case where the function raises an exception that is not an instance of Error
+};
+
+describe("Issue #2", () => {
+  it("Exception if function passed raised an exception with a correct Error Object", async () => {
+    const engine = cleverQueue.createEngine(engineOptions);
+    const queue1 = engine.createQueue({
+      name: "A",
+      priority: cleverQueue.queues.Priorities.Absolute,
+      weight: 50,
+    });
+    const customErrorMessage = "Custom error message";
+    try {
+      await assert.rejects(
+        async () => {
+          const myTask = engine.createTask(() => task(customErrorMessage), {});
+          await queue1.enqueue(myTask);
+        },
+        { name: "Error", message: customErrorMessage },
+      );
+    } finally {
+      engine.stop();
+    }
+  });
+});

package/test/issues/00008-error-contract.mjs

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+const engineOptions = {
+  bestEffortRunners: 1,
+};
+
+async function runFailingTask(thrownValue) {
+  const engine = cleverQueue.createEngine(engineOptions);
+  const queue = engine.createQueue({
+    priority: cleverQueue.queues.Priorities.Absolute,
+    weight: 50,
+  });
+
+  try {
+    await queue.enqueue(
+      engine.createTask(async () => {
+        throw thrownValue;
+      }, {}),
+    );
+    throw new Error("task was expected to reject");
+  } finally {
+    engine.stop();
+  }
+}
+
+describe("Issue #8 - task error propagation contract", () => {
+  it("rejects with the original Error instance when a task throws an Error", async () => {
+    const originalError = new Error("original error");
+
+    await assert.rejects(() => runFailingTask(originalError), (error) => {
+      assert.equal(error, originalError);
+      return true;
+    });
+  });
+
+  it("wraps thrown strings in the documented CQError fallback", async () => {
+    await assert.rejects(() => runFailingTask("boom"), {
+      name: cleverQueue.tasks.ErrorsList.FunctionRaisedAnHundledException.name,
+      message: cleverQueue.tasks.ErrorsList.FunctionRaisedAnHundledException.message,
+    });
+  });
+
+  it("wraps thrown objects in the documented CQError fallback", async () => {
+    await assert.rejects(() => runFailingTask({ code: "E_OBJECT" }), {
+      name: cleverQueue.tasks.ErrorsList.FunctionRaisedAnHundledException.name,
+      message: cleverQueue.tasks.ErrorsList.FunctionRaisedAnHundledException.message,
+    });
+  });
+});

package/test/issues/00009-weight-semantics.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+async function dequeueIds(engine, count) {
+  const ids = [];
+  for (let index = 0; index < count; index += 1) {
+    const task = await engine.getNextTask(cleverQueue.queues.Priorities.BestEffort);
+    assert.ok(task);
+    ids.push(task.options.id);
+  }
+
+  return ids;
+}
+
+describe("Issue #9 - queue weight semantics", () => {
+  it("exposes 1 as the lowest valid queue weight", () => {
+    assert.equal(cleverQueue.queues.Weights.Lowest, 1);
+  });
+
+  it("rejects weight 0 because active queues must have a positive scheduling weight", () => {
+    const engine = cleverQueue.createEngine({ bestEffortRunners: 1 });
+
+    assert.throws(
+      () =>
+        engine.createQueue({
+          priority: cleverQueue.queues.Priorities.Standard,
+          weight: 0,
+        }),
+      {
+        name: cleverQueue.queues.ErrorsList.NoWeightOptionsOnQueueInitialization.name,
+        message: cleverQueue.queues.ErrorsList.NoWeightOptionsOnQueueInitialization.message,
+      },
+    );
+
+    engine.stop();
+  });
+
+  it("uses larger weights to receive proportionally more scheduling turns over time", async () => {
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const heavyQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 2 });
+    const lightQueue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    for (let index = 0; index < 4; index += 1) heavyQueue.enqueue(engine.createTask(() => undefined, { id: `heavy-${index}` }));
+    for (let index = 0; index < 2; index += 1) lightQueue.enqueue(engine.createTask(() => undefined, { id: `light-${index}` }));
+
+    engine.start();
+    const ids = await dequeueIds(engine, 6);
+
+    assert.deepEqual(ids, ["heavy-0", "heavy-1", "light-0", "heavy-2", "heavy-3", "light-1"]);
+    engine.stop();
+  });
+});

package/test/issues/00010-lifecycle-semantics.mjs

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+function createDeferred() {
+  /** @type {(value?: unknown) => void} */
+  let resolve;
+  const promise = new Promise((resolver) => {
+    resolve = resolver;
+  });
+
+  return { promise, resolve };
+}
+
+describe("Issue #10 - lifecycle semantics", () => {
+  it("rejects queued tasks when the engine is stopped, while letting the in-flight task finish", async () => {
+    const blocker = createDeferred();
+    const engine = cleverQueue.createEngine({ bestEffortRunners: 1 });
+    const queue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    const firstTask = queue.enqueue(
+      engine.createTask(async () => {
+        await blocker.promise;
+        return "first";
+      }, {}),
+    );
+    const secondTask = queue.enqueue(engine.createTask(() => "second", {}));
+
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    engine.stop();
+    blocker.resolve();
+
+    assert.equal(await firstTask, "first");
+    await assert.rejects(secondTask, {
+      name: cleverQueue.queues.ErrorsList.QueueIsStopping.name,
+    });
+  });
+
+  it("rejects pending tasks immediately when a queue is stopped", async () => {
+    const engine = cleverQueue.createEngine({ bestEffortRunners: 1 });
+    const queue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+    const pendingTask = queue.enqueue(engine.createTask(() => "never runs", {}));
+
+    queue.stop();
+
+    await assert.rejects(pendingTask, {
+      name: cleverQueue.queues.ErrorsList.QueueIsStopping.name,
+    });
+    engine.stop();
+  });
+
+  it("lets a runner finish its current task before stopping without starting the next one", async () => {
+    const blocker = createDeferred();
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const queue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+    const runner = engine.runners[0];
+
+    const firstTask = queue.enqueue(
+      engine.createTask(async () => {
+        await blocker.promise;
+        return "first";
+      }, {}),
+    );
+    const secondTask = queue.enqueue(engine.createTask(() => "second", {}));
+
+    engine.start();
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    runner.stop();
+    blocker.resolve();
+
+    assert.equal(await firstTask, "first");
+    assert.equal(runner.statistics().status, "stopping");
+
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    assert.equal(queue.statistics().tasks, 1);
+
+    queue.stop();
+    await assert.rejects(secondTask, {
+      name: cleverQueue.queues.ErrorsList.QueueIsStopping.name,
+    });
+    engine.stop();
+  });
+
+  it("rejects new tasks after a queue has been stopped", async () => {
+    const engine = cleverQueue.createEngine({ bestEffortRunners: 1 });
+    const queue = engine.createQueue({ priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+
+    queue.stop();
+
+    await assert.rejects(
+      queue.enqueue(engine.createTask(() => "late", {})),
+      {
+        name: cleverQueue.queues.ErrorsList.QueueIsStopping.name,
+        message: cleverQueue.queues.ErrorsList.QueueIsStopping.message,
+      },
+    );
+
+    engine.stop();
+  });
+});

package/test/issues/00012-wording-cleanup.mjs

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import * as cleverQueue from "../../dist/index.js";
+
+describe("Issue #12 - wording and status cleanup", () => {
+  it("uses the normalized initializing status wording across runtime objects", () => {
+    const task = new cleverQueue.tasks.Task(() => undefined, { autostart: false });
+    assert.equal(task.statistics().status, "initializing");
+
+    const engine = cleverQueue.createEngine({ autostart: false, bestEffortRunners: 1 });
+    const queue = engine.createQueue({ autostart: false, priority: cleverQueue.queues.Priorities.Standard, weight: 1 });
+    const runner = engine.createRunner({ autostart: false, priority: cleverQueue.queues.Priorities.BestEffort });
+
+    assert.equal(engine.statistics().engine.status, "initializing");
+    assert.equal(queue.statistics().status, "initializing");
+    assert.equal(runner.statistics().status, "initializing");
+    engine.stop();
+  });
+
+  it("reports completed instead of runned after successful task execution", async () => {
+    const task = new cleverQueue.tasks.Task(() => "done", {});
+    task.resolver = () => {};
+    task.rejecter = () => {};
+
+    await task.run();
+
+    assert.equal(task.statistics().status, "completed");
+  });
+});

package/test/miscellaneous/test.mjs

@@ -8,27 +8,32 @@ const engineOptions = {
   logFunction: undefined,
 };
 
+function trackEnqueue(promises, queue, task) {
+  promises.push(queue.enqueue(task).catch(() => undefined));
+}
+
 describe("Scheduler Unit Tests", () => {
   it("Priority Test", () => {
+    const pending = [];
     const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
-    for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue1, engine.createTask(() => {}, {}));
     const queue2 = engine.createQueue({
       name: "B",
       priority: cleverQueue.queues.Priorities.Standard,
       weight: 50,
     });
-    for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue2, engine.createTask(() => {}, {}));
     const queue3 = engine.createQueue({
       name: "C",
       priority: cleverQueue.queues.Priorities.BestEffort,
       weight: 50,
     });
-    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue3, engine.createTask(() => {}, {}));
 
     const engineStatistics = engine.statistics();
     assert.equal(engineStatistics.engine.queues, 3);
@@ -36,25 +41,26 @@ describe("Scheduler Unit Tests", () => {
   });
 
   it("Weighted Test", () => {
+    const pending = [];
     const engine = cleverQueue.createEngine(engineOptions);
     const queue1 = engine.createQueue({
       name: "A",
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 80,
     });
-    for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue1, engine.createTask(() => {}, {}));
     const queue2 = engine.createQueue({
       name: "B",
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 50,
     });
-    for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue2, engine.createTask(() => {}, {}));
     const queue3 = engine.createQueue({
       name: "C",
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 20,
     });
-    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue3, engine.createTask(() => {}, {}));
 
     const engineStatistics = engine.statistics();
     assert.equal(engineStatistics.engine.queues, 3);
@@ -62,6 +68,7 @@ describe("Scheduler Unit Tests", () => {
   });
 
   it("Combine Test", () => {
+    const pending = [];
     const engine = cleverQueue.createEngine(engineOptions);
 
     const queue1 = engine.createQueue({
@@ -69,21 +76,21 @@ describe("Scheduler Unit Tests", () => {
       priority: cleverQueue.queues.Priorities.Absolute,
       weight: 80,
     });
-    for (let index = 0; index < 100; index++) queue1.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue1, engine.createTask(() => {}, {}));
 
     const queue2 = engine.createQueue({
       name: "B - Standard - 50",
       priority: cleverQueue.queues.Priorities.Standard,
       weight: 50,
     });
-    for (let index = 0; index < 100; index++) queue2.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue2, engine.createTask(() => {}, {}));
 
     const queue3 = engine.createQueue({
       name: "C- Standard - 20",
       priority: cleverQueue.queues.Priorities.Standard,
       weight: 20,
     });
-    for (let index = 0; index < 100; index++) queue3.enqueue(engine.createTask(() => {}, {}));
+    for (let index = 0; index < 100; index++) trackEnqueue(pending, queue3, engine.createTask(() => {}, {}));
 
     const engineStatistics = engine.statistics();
     assert.equal(engineStatistics.engine.queues, 3);

package/test/units/engine.mjs

@@ -4,7 +4,7 @@ import { describe, it } from "node:test";
 import * as cleverQueue from "../../dist/index.js";
 
 describe("Engine Class Unit Tests", () => {
-  it("Successfull Initialisation without any option (use hardcoded default options)", () => {
+  it("Successful Initialisation without any option (use hardcoded default options)", () => {
     const engine = cleverQueue.createEngine();
     const statistics = engine.statistics();
     assert.equal(statistics.engine.runners, 1);
@@ -22,7 +22,7 @@ describe("Engine Class Unit Tests", () => {
     );
   });
 
-  it("Successfull Initialisation with 3 Runners", () => {
+  it("Successful Initialisation with 3 Runners", () => {
     const engineOptions = {
       bestEffortRunners: 3,
     };

package/test/units/queue.mjs

@@ -9,7 +9,7 @@ const engineOptions = {
 };
 
 describe("Queue Class Unit Tests", () => {
-  it("Successfull Initialisation without any option (use hardcoded default options)", () => {
+  it("Successful Initialisation without any option (use hardcoded default options)", () => {
     const engine = cleverQueue.createEngine();
     const statistics = engine.statistics();
     assert.equal(statistics.engine.runners, 1);
@@ -17,7 +17,7 @@ describe("Queue Class Unit Tests", () => {
     engine.stop();
   });
 
-  it("Successfull Initialisation", () => {
+  it("Successful Initialisation", () => {
     const engine = cleverQueue.createEngine(engineOptions);
     const queueOptions = {
       priority: cleverQueue.queues.Priorities.Standard,
@@ -31,4 +31,21 @@ describe("Queue Class Unit Tests", () => {
     assert.equal(queueStatistics.weight, queueOptions.weight);
     engine.stop();
   });
+
+  it("Rejects negative weight because queue weights must stay within the supported range", () => {
+    const engine = cleverQueue.createEngine(engineOptions);
+    assert.throws(
+      () =>
+        engine.createQueue({
+          priority: cleverQueue.queues.Priorities.Standard,
+          weight: -1,
+        }),
+      { name: cleverQueue.queues.ErrorsList.NoWeightOptionsOnQueueInitialization.name },
+    );
+    engine.stop();
+  });
+
+  it("Keeps the exported lowest weight constant at one", () => {
+    assert.equal(cleverQueue.queues.Weights.Lowest, 1);
+  });
 });