3 from __future__ import absolute_import, print_function
7 import arvnodeman.jobqueue as jobqueue
10 class ServerCalculatorTestCase(unittest.TestCase):
11 def make_calculator(self, factors, **kwargs):
12 return jobqueue.ServerCalculator(
13 [(testutil.MockSize(n), {'cores': n}) for n in factors], **kwargs)
15 def calculate(self, servcalc, *constraints):
16 return servcalc.servers_for_queue(
17 [{'uuid': 'zzzzz-jjjjj-{:015x}'.format(index),
18 'runtime_constraints': cdict}
19 for index, cdict in enumerate(constraints)])
21 def test_empty_queue_needs_no_servers(self):
22 servcalc = self.make_calculator([1])
23 self.assertEqual([], servcalc.servers_for_queue([]))
25 def test_easy_server_count(self):
26 servcalc = self.make_calculator([1])
27 servlist = self.calculate(servcalc, {'min_nodes': 3})
28 self.assertEqual(3, len(servlist))
30 def test_implicit_server_count(self):
31 servcalc = self.make_calculator([1])
32 servlist = self.calculate(servcalc, {}, {'min_nodes': 3})
33 self.assertEqual(4, len(servlist))
35 def test_bad_min_nodes_override(self):
36 servcalc = self.make_calculator([1])
37 servlist = self.calculate(servcalc,
38 {'min_nodes': -2}, {'min_nodes': 'foo'})
39 self.assertEqual(2, len(servlist))
41 def test_ignore_unsatisfiable_jobs(self):
42 servcalc = self.make_calculator([1], max_nodes=9)
43 servlist = self.calculate(servcalc,
44 {'min_cores_per_node': 2},
45 {'min_ram_mb_per_node': 256},
48 {'min_scratch_mb_per_node': 200})
49 self.assertEqual(6, len(servlist))
51 def test_job_requesting_max_nodes_accepted(self):
52 servcalc = self.make_calculator([1], max_nodes=4)
53 servlist = self.calculate(servcalc, {'min_nodes': 4})
54 self.assertEqual(4, len(servlist))
56 def test_cheapest_size(self):
57 servcalc = self.make_calculator([2, 4, 1, 3])
58 self.assertEqual(testutil.MockSize(1), servcalc.cheapest_size())
60 def test_next_biggest(self):
61 servcalc = self.make_calculator([1, 2, 4, 8])
62 servlist = self.calculate(servcalc,
63 {'min_cores_per_node': 3},
64 {'min_cores_per_node': 6})
65 self.assertEqual([servcalc.cloud_sizes[2].id,
66 servcalc.cloud_sizes[3].id],
67 [s.id for s in servlist])
69 def test_multiple_sizes(self):
70 servcalc = self.make_calculator([1, 2])
71 servlist = self.calculate(servcalc,
72 {'min_cores_per_node': 2},
73 {'min_cores_per_node': 1},
74 {'min_cores_per_node': 1})
75 self.assertEqual([servcalc.cloud_sizes[1].id,
76 servcalc.cloud_sizes[0].id,
77 servcalc.cloud_sizes[0].id],
78 [s.id for s in servlist])
80 servlist = self.calculate(servcalc,
81 {'min_cores_per_node': 1},
82 {'min_cores_per_node': 2},
83 {'min_cores_per_node': 1})
84 self.assertEqual([servcalc.cloud_sizes[0].id,
85 servcalc.cloud_sizes[1].id,
86 servcalc.cloud_sizes[0].id],
87 [s.id for s in servlist])
89 servlist = self.calculate(servcalc,
90 {'min_cores_per_node': 1},
91 {'min_cores_per_node': 1},
92 {'min_cores_per_node': 2})
93 self.assertEqual([servcalc.cloud_sizes[0].id,
94 servcalc.cloud_sizes[0].id,
95 servcalc.cloud_sizes[1].id],
96 [s.id for s in servlist])
100 class JobQueueMonitorActorTestCase(testutil.RemotePollLoopActorTestMixin,
102 TEST_CLASS = jobqueue.JobQueueMonitorActor
104 class MockCalculator(object):
106 def servers_for_queue(queue):
107 return [testutil.MockSize(n) for n in queue]
110 def build_monitor(self, side_effect, *args, **kwargs):
111 super(JobQueueMonitorActorTestCase, self).build_monitor(*args, **kwargs)
112 self.client.jobs().queue().execute.side_effect = side_effect
114 def test_subscribers_get_server_lists(self):
115 self.build_monitor([{'items': [1, 2]}], self.MockCalculator())
116 self.monitor.subscribe(self.subscriber).get(self.TIMEOUT)
117 self.stop_proxy(self.monitor)
118 self.subscriber.assert_called_with([testutil.MockSize(1),
119 testutil.MockSize(2)])
122 if __name__ == '__main__':