expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
await pool.destroy()
})
- it('Verify ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
+ it('Verify ROUND_ROBIN strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify ROUND_ROBIN strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.ROUND_ROBIN
let pool = new FixedThreadPool(
max,
executed: maxMultiplier,
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
executed: maxMultiplier,
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
await pool.destroy()
})
- it('Verify LEAST_USED strategy default tasks usage statistics requirements', async () => {
+ it('Verify LEAST_USED strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_USED
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify LEAST_USED strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_USED
let pool = new FixedThreadPool(
max,
for (const workerNode of pool.workerNodes) {
expect(workerNode.workerUsage).toStrictEqual({
tasks: {
- executed: maxMultiplier,
+ executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
utilization: 0
}
})
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
}
// We need to clean up the resources after our test
await pool.destroy()
for (const workerNode of pool.workerNodes) {
expect(workerNode.workerUsage).toStrictEqual({
tasks: {
- executed: maxMultiplier,
+ executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
utilization: 0
}
})
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
}
// We need to clean up the resources after our test
await pool.destroy()
})
- it('Verify LEAST_BUSY strategy default tasks usage statistics requirements', async () => {
+ it('Verify LEAST_BUSY strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_BUSY
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify LEAST_BUSY strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_BUSY
let pool = new FixedThreadPool(
max,
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
utilization: 0
}
})
- expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
max * maxMultiplier
)
- expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThan(0)
- expect(workerNode.workerUsage.waitTime.aggregate).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.waitTime.aggregate).toBeGreaterThanOrEqual(
+ 0
+ )
}
// We need to clean up the resources after our test
await pool.destroy()
})
- it('Verify LEAST_ELU strategy default tasks usage statistics requirements', async () => {
+ it('Verify LEAST_ELU strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_ELU
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify LEAST_ELU strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.LEAST_ELU
let pool = new FixedThreadPool(
max,
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
await pool.destroy()
})
- it('Verify FAIR_SHARE strategy default tasks usage statistics requirements', async () => {
+ it('Verify FAIR_SHARE strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: false
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify FAIR_SHARE strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.FAIR_SHARE
let pool = new FixedThreadPool(
max,
median: false
},
elu: {
- aggregate: false,
- average: false,
+ aggregate: true,
+ average: true,
median: false
}
})
median: false
},
elu: {
- aggregate: false,
- average: false,
+ aggregate: true,
+ average: true,
median: false
}
})
for (const workerNode of pool.workerNodes) {
expect(workerNode.workerUsage).toStrictEqual({
tasks: {
- executed: maxMultiplier,
+ executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- average: 0,
+ aggregate: expect.any(Number),
+ average: expect.any(Number),
median: 0,
history: expect.any(CircularArray)
},
- utilization: 0
+ utilization: expect.any(Number)
}
})
- expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThan(0)
- expect(workerNode.workerUsage.runTime.average).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeLessThanOrEqual(1)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
for (const workerNode of pool.workerNodes) {
expect(workerNode.workerUsage).toStrictEqual({
tasks: {
- executed: maxMultiplier,
+ executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- average: 0,
+ aggregate: expect.any(Number),
+ average: expect.any(Number),
median: 0,
history: expect.any(CircularArray)
},
- utilization: 0
+ utilization: expect.any(Number)
}
})
- expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThan(0)
- expect(workerNode.workerUsage.runTime.average).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeLessThanOrEqual(1)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
for (const workerNode of pool.workerNodes) {
expect(workerNode.workerUsage).toStrictEqual({
tasks: {
- executed: maxMultiplier,
+ executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
history: expect.any(CircularArray)
},
active: {
- aggregate: 0,
- average: 0,
+ aggregate: expect.any(Number),
+ average: expect.any(Number),
median: 0,
history: expect.any(CircularArray)
},
- utilization: 0
+ utilization: expect.any(Number)
}
})
- expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThan(0)
- expect(workerNode.workerUsage.runTime.median).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregate).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.runTime.median).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.elu.utilization).toBeLessThanOrEqual(1)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
await pool.destroy()
})
- it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
+ it('Verify WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
+ const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy = WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN
let pool = new FixedThreadPool(
max,
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
utilization: 0
}
})
- expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
max * maxMultiplier
)
executed: expect.any(Number),
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
utilization: 0
}
})
- expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
max * maxMultiplier
)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
await pool.destroy()
})
- it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks usage statistics requirements', async () => {
+ it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default policy', async () => {
+ const workerChoiceStrategy =
+ WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js',
+ { workerChoiceStrategy }
+ )
+ expect(pool.workerChoiceStrategyContext.getStrategyPolicy()).toStrictEqual({
+ useDynamicWorker: true
+ })
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
+ it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy default tasks statistics requirements', async () => {
const workerChoiceStrategy =
WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
let pool = new FixedThreadPool(
executed: maxMultiplier,
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentRoundId
+ ).roundId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
executed: maxMultiplier,
executing: 0,
queued: 0,
+ maxQueued: 0,
failed: 0
},
runTime: {
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentRoundId
+ ).roundId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentRoundId
+ ).roundId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentRoundId
+ ).roundId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentRoundId
+ ).roundId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBeDefined()
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
pool.workerChoiceStrategyContext.workerChoiceStrategy
- ).currentWorkerNodeId
+ ).nextWorkerNodeId
).toBe(0)
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(