FilesExpand file tree

main

/

test-coordinator.test.mjs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

90 lines (82 loc) · 2.54 KB

main

/

test-coordinator.test.mjs

Copy path

Top

File metadata and controls

• Code
• Blame

90 lines (82 loc) · 2.54 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

// SPDX-License-Identifier: AGPL-3.0-or-later

import assert from "node:assert";

import { computeOptimalAllocation } from "../scripts/test-coordinator.js";

// Test 1: Current machine (16 CPUs, 32GB RAM, 21GB free, 22 projects)

{

const res = computeOptimalAllocation({

cpus: 16,

freeMem: 21 * 1024 * 1024 * 1024,

totalMem: 32 * 1024 * 1024 * 1024,

targetCount: 22,

});

assert.strictEqual(res.totalBudget, 16);

assert.strictEqual(res.tasks, 4);

assert.strictEqual(res.workers, 4);

assert.strictEqual(res.totalConcurrency, 16);

}

// Test 2: Low memory machine (16 CPUs, but only 2GB free out of 8GB total)

{

const res = computeOptimalAllocation({

cpus: 16,

freeMem: 2 * 1024 * 1024 * 1024,

totalMem: 8 * 1024 * 1024 * 1024,

targetCount: 10,

});

// Reserve: 2GB * 0.15 = 300MB -> clamped to 500MB

// Avail: 2GB - 0.5GB = 1.5GB -> floor(1.5GB / 750MB) = 2 workers

assert.strictEqual(res.totalBudget, 2);

assert.strictEqual(res.tasks, 1);

assert.strictEqual(res.workers, 2);

}

// Test 3: Moderate machine (8 CPUs, 16GB RAM, 10GB free, 15 projects)

{

const res = computeOptimalAllocation({

cpus: 8,

freeMem: 10 * 1024 * 1024 * 1024,

totalMem: 16 * 1024 * 1024 * 1024,

targetCount: 15,

});

assert.strictEqual(res.totalBudget, 8);

assert.strictEqual(res.tasks, 2);

assert.strictEqual(res.workers, 4);

assert.strictEqual(res.totalConcurrency, 8);

}

// Test 4: Laptop (4 CPUs, 8GB RAM, 4GB free, 8 projects)

{

const res = computeOptimalAllocation({

cpus: 4,

freeMem: 4 * 1024 * 1024 * 1024,

totalMem: 8 * 1024 * 1024 * 1024,

targetCount: 8,

});

// Reserve: 4GB * 0.15 = 600MB

// Avail: 4GB - 0.6GB = 3.4GB -> floor(3.4GB / 750MB) = 4 workers (capped at 4 CPUs)

assert.strictEqual(res.totalBudget, 4);

assert.strictEqual(res.tasks, 2);

assert.strictEqual(res.workers, 2);

}

// Test 5: Single target on large machine (16 CPUs, 32GB RAM, targetCount: 1)

{

const res = computeOptimalAllocation({

cpus: 16,

freeMem: 20 * 1024 * 1024 * 1024,

totalMem: 32 * 1024 * 1024 * 1024,

targetCount: 1,

});

assert.strictEqual(res.tasks, 1);

assert.strictEqual(res.workers, 12);

}

// Test 6: Explicit user overrides

{

const res = computeOptimalAllocation({

cpus: 16,

freeMem: 20 * 1024 * 1024 * 1024,

totalMem: 32 * 1024 * 1024 * 1024,

userTasks: 8,

userWorkers: 2,

});

assert.strictEqual(res.tasks, 8);

assert.strictEqual(res.workers, 2);

assert.strictEqual(res.totalConcurrency, 16);

}

console.log("All computeOptimalAllocation unit tests passed!");