it('Verify that WorkerChoiceStrategies enumeration provides string values', () => {
expect(WorkerChoiceStrategies.ROUND_ROBIN).toBe('ROUND_ROBIN')
expect(WorkerChoiceStrategies.LEAST_USED).toBe('LEAST_USED')
+ expect(WorkerChoiceStrategies.LEAST_ELU).toBe('LEAST_ELU')
expect(WorkerChoiceStrategies.LEAST_BUSY).toBe('LEAST_BUSY')
expect(WorkerChoiceStrategies.FAIR_SHARE).toBe('FAIR_SHARE')
expect(WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN).toBe(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
expect(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
expect(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
// We need to clean up the resources after our test
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+
+ elu: undefined
})
}
// We need to clean up the resources after our test
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThanOrEqual(
+ 0
+ )
}
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
}
// We need to clean up the resources after our test
await pool.destroy()
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: expect.any(Number),
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: expect.any(Number),
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThan(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: expect.any(Number),
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: expect.any(Number),
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThan(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: expect.any(Number),
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: 0,
+ median: expect.any(Number),
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.median).toBeGreaterThan(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: true,
avgRunTime: true,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: expect.any(Number),
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: expect.any(Number),
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThanOrEqual(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThanOrEqual(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThanOrEqual(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThanOrEqual(
+ 0
+ )
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThanOrEqual(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: expect.any(Number),
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: expect.any(Number),
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.average).toBeGreaterThan(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: expect.any(Number),
- running: 0,
- runTime: expect.any(Number),
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: expect.any(Number),
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: expect.any(Number),
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: expect.any(Number),
+ average: 0,
+ median: expect.any(Number),
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.tasks.executed).toBeLessThanOrEqual(
+ max * maxMultiplier
+ )
+ expect(workerNode.workerUsage.runTime.aggregation).toBeGreaterThan(0)
+ expect(workerNode.workerUsage.runTime.median).toBeGreaterThan(0)
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
await pool.destroy()
pool = new DynamicThreadPool(
'./tests/worker-files/thread/testWorker.js',
{ workerChoiceStrategy }
)
- expect(
- pool.workerChoiceStrategyContext.getRequiredStatistics()
- ).toStrictEqual({
+ expect(pool.workerChoiceStrategyContext.getTaskStatistics()).toStrictEqual({
runTime: false,
avgRunTime: false,
medRunTime: false,
waitTime: false,
avgWaitTime: false,
- medWaitTime: false
+ medWaitTime: false,
+ elu: false
})
// We need to clean up the resources after our test
await pool.destroy()
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
expect(
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toStrictEqual({
- run: maxMultiplier,
- running: 0,
- runTime: 0,
- runTimeHistory: expect.any(CircularArray),
- avgRunTime: 0,
- medRunTime: 0,
- waitTime: 0,
- waitTimeHistory: expect.any(CircularArray),
- avgWaitTime: 0,
- medWaitTime: 0,
- error: 0
+ expect(workerNode.workerUsage).toStrictEqual({
+ tasks: {
+ executed: maxMultiplier,
+ executing: 0,
+ queued: 0,
+ failed: 0
+ },
+ runTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ waitTime: {
+ aggregation: 0,
+ average: 0,
+ median: 0,
+ history: expect.any(CircularArray)
+ },
+ elu: undefined
})
}
expect(
await pool.destroy()
})
+ it('Verify INTERLEAVED_WEIGHTED_ROUND_ROBIN strategy internals are resets after setting it', async () => {
+ const workerChoiceStrategy =
+ WorkerChoiceStrategies.INTERLEAVED_WEIGHTED_ROUND_ROBIN
+ let pool = new FixedThreadPool(
+ max,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).currentRoundId
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).currentWorkerNodeId
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).defaultWorkerWeight
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).roundWeights
+ ).toBeDefined()
+ pool.setWorkerChoiceStrategy(workerChoiceStrategy)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).currentRoundId
+ ).toBe(0)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).currentWorkerNodeId
+ ).toBe(0)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).defaultWorkerWeight
+ ).toBeGreaterThan(0)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).roundWeights
+ ).toStrictEqual([
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).defaultWorkerWeight
+ ])
+ await pool.destroy()
+ pool = new DynamicThreadPool(
+ min,
+ max,
+ './tests/worker-files/thread/testWorker.js'
+ )
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).currentRoundId
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).currentWorkerNodeId
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).defaultWorkerWeight
+ ).toBeDefined()
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).roundWeights
+ ).toBeDefined()
+ pool.setWorkerChoiceStrategy(workerChoiceStrategy)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).currentWorkerNodeId
+ ).toBe(0)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).defaultWorkerWeight
+ ).toBeGreaterThan(0)
+ expect(
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ workerChoiceStrategy
+ ).roundWeights
+ ).toStrictEqual([
+ pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
+ pool.workerChoiceStrategyContext.workerChoiceStrategy
+ ).defaultWorkerWeight
+ ])
+ // We need to clean up the resources after our test
+ await pool.destroy()
+ })
+
it('Verify unknown strategy throw error', () => {
expect(
() =>