summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
e211bc1)
Signed-off-by: Jérôme Benoit <jerome.benoit@sap.com>
'./tests/worker-files/thread/testWorker.js'
)
const promises = []
'./tests/worker-files/thread/testWorker.js'
)
const promises = []
- for (let i = 0; i < numberOfWorkers * 2; i++) {
+ const maxMultiplier = 2
+ for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
promises.push(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
promises.push(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
expect(workerNode.tasksUsage).toStrictEqual({
- run: numberOfWorkers * 2,
+ run: numberOfWorkers * maxMultiplier,
- runTime: expect.any(Number),
runTimeHistory: expect.any(CircularArray),
avgRunTime: 0,
medRunTime: 0,
runTimeHistory: expect.any(CircularArray),
avgRunTime: 0,
medRunTime: 0,
medWaitTime: 0,
error: 0
})
medWaitTime: 0,
error: 0
})
- expect(workerNode.tasksUsage.runTime).toBeGreaterThanOrEqual(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThanOrEqual(0)
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
}
pool.setWorkerChoiceStrategy(WorkerChoiceStrategies.FAIR_SHARE)
for (const workerNode of pool.workerNodes) {
- expect(workerNode.tasksUsage).toBeDefined()
expect(workerNode.tasksUsage).toStrictEqual({
run: 0,
running: 0,
expect(workerNode.tasksUsage).toStrictEqual({
run: 0,
running: 0,
error: 0
})
expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
error: 0
})
expect(workerNode.tasksUsage.runTimeHistory.length).toBe(0)
+ expect(workerNode.tasksUsage.waitTimeHistory.length).toBe(0)
}
await pool.destroy()
})
}
await pool.destroy()
})
})
it('Verify that tasks queuing is working', async () => {
})
it('Verify that tasks queuing is working', async () => {
- const maxMultiplier = 2
const promises = new Set()
const promises = new Set()
+ const maxMultiplier = 2
for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
promises.add(queuePool.execute())
}
for (let i = 0; i < numberOfWorkers * maxMultiplier; i++) {
promises.add(queuePool.execute())
}
for (const workerNode of queuePool.workerNodes) {
expect(workerNode.tasksUsage.running).toBe(0)
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
for (const workerNode of queuePool.workerNodes) {
expect(workerNode.tasksUsage.running).toBe(0)
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(
+ numberOfWorkers * maxMultiplier
+ )
expect(workerNode.tasksQueue.size).toBe(0)
}
promises.clear()
expect(workerNode.tasksQueue.size).toBe(0)
}
promises.clear()
{ workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
)
// TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
)
// TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
}
// We need to clean up the resources after our test
await pool.destroy()
}
// We need to clean up the resources after our test
await pool.destroy()
{ workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
)
// TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.ROUND_ROBIN }
)
// TODO: Create a better test to cover `RoundRobinWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
}
// We need to clean up the resources after our test
await pool.destroy()
}
// We need to clean up the resources after our test
await pool.destroy()
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
)
// TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
)
// TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
}
// We need to clean up the resources after our test
await pool.destroy()
}
// We need to clean up the resources after our test
await pool.destroy()
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
)
// TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_USED }
)
// TODO: Create a better test to cover `LeastUsedWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
}
// We need to clean up the resources after our test
await pool.destroy()
}
// We need to clean up the resources after our test
await pool.destroy()
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
)
// TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
)
// TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
}
// We need to clean up the resources after our test
expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
}
// We need to clean up the resources after our test
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
)
// TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.LEAST_BUSY }
)
// TODO: Create a better test to cover `LeastBusyWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(max * maxMultiplier)
expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
}
// We need to clean up the resources after our test
expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
}
// We need to clean up the resources after our test
{ workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
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.tasksUsage.runTime).toBeGreaterThan(0)
expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
}
{ workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.FAIR_SHARE }
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
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.tasksUsage.runTime).toBeGreaterThan(0)
expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
}
}
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
}
)
// TODO: Create a better test to cover `FairShareChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
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.tasksUsage.runTime).toBeGreaterThan(0)
expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
}
{ workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
medWaitTime: 0,
error: 0
})
medWaitTime: 0,
error: 0
})
- expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.runTime).toBeGreaterThan(0)
- expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
+ 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(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
}
expect(
pool.workerChoiceStrategyContext.workerChoiceStrategies.get(
{ workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
{ workerChoiceStrategy: WorkerChoiceStrategies.WEIGHTED_ROUND_ROBIN }
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
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.tasksUsage.runTime).toBeGreaterThan(0)
expect(workerNode.tasksUsage.avgRunTime).toBeGreaterThan(0)
}
}
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
}
)
// TODO: Create a better test to cover `WeightedRoundRobinWorkerChoiceStrategy#choose`
+ const promises = new Set()
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
const maxMultiplier = 2
for (let i = 0; i < max * maxMultiplier; i++) {
- promises.push(pool.execute())
+ promises.add(pool.execute())
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
}
await Promise.all(promises)
for (const workerNode of pool.workerNodes) {
error: 0
})
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
error: 0
})
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.tasksUsage.runTime).toBeGreaterThan(0)
expect(workerNode.tasksUsage.medRunTime).toBeGreaterThan(0)
}
})
it('Verify that tasks queuing is working', async () => {
})
it('Verify that tasks queuing is working', async () => {
- const maxMultiplier = 2
const promises = new Set()
const promises = new Set()
+ const maxMultiplier = 2
for (let i = 0; i < numberOfThreads * maxMultiplier; i++) {
promises.add(queuePool.execute())
}
for (let i = 0; i < numberOfThreads * maxMultiplier; i++) {
promises.add(queuePool.execute())
}
for (const workerNode of queuePool.workerNodes) {
expect(workerNode.tasksUsage.running).toBe(0)
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
for (const workerNode of queuePool.workerNodes) {
expect(workerNode.tasksUsage.running).toBe(0)
expect(workerNode.tasksUsage.run).toBeGreaterThan(0)
+ expect(workerNode.tasksUsage.run).toBeLessThanOrEqual(
+ numberOfThreads * maxMultiplier
+ )
expect(workerNode.tasksQueue.size).toBe(0)
}
promises.clear()
expect(workerNode.tasksQueue.size).toBe(0)
}
promises.clear()