services/nodemanager/tests/test_jobqueue.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import absolute_import, print_function
   4
   5 import unittest
   6 import mock
   7
   8 import arvnodeman.jobqueue as jobqueue
   9 from . import testutil
  10
  11 class ServerCalculatorTestCase(unittest.TestCase):
  12     def make_calculator(self, factors, **kwargs):
  13         return jobqueue.ServerCalculator(
  14             [(testutil.MockSize(n), {'cores': n}) for n in factors], **kwargs)
  15
  16     def calculate(self, servcalc, *constraints):
  17         return servcalc.servers_for_queue(
  18             [{'uuid': 'zzzzz-jjjjj-{:015x}'.format(index),
  19               'runtime_constraints': cdict}
  20              for index, cdict in enumerate(constraints)])
  21
  22     def test_empty_queue_needs_no_servers(self):
  23         servcalc = self.make_calculator([1])
  24         self.assertEqual([], servcalc.servers_for_queue([]))
  25
  26     def test_easy_server_count(self):
  27         servcalc = self.make_calculator([1])
  28         servlist = self.calculate(servcalc, {'min_nodes': 3})
  29         self.assertEqual(3, len(servlist))
  30
  31     def test_default_5pct_ram_value_decrease(self):
  32         servcalc = self.make_calculator([1])
  33         servlist = self.calculate(servcalc, {'min_ram_mb_per_node': 128})
  34         self.assertEqual(0, len(servlist))
  35         servlist = self.calculate(servcalc, {'min_ram_mb_per_node': 121})
  36         self.assertEqual(1, len(servlist))
  37
  38     def test_implicit_server_count(self):
  39         servcalc = self.make_calculator([1])
  40         servlist = self.calculate(servcalc, {}, {'min_nodes': 3})
  41         self.assertEqual(4, len(servlist))
  42
  43     def test_bad_min_nodes_override(self):
  44         servcalc = self.make_calculator([1])
  45         servlist = self.calculate(servcalc,
  46                                   {'min_nodes': -2}, {'min_nodes': 'foo'})
  47         self.assertEqual(2, len(servlist))
  48
  49     def test_ignore_unsatisfiable_jobs(self):
  50         servcalc = self.make_calculator([1], max_nodes=9)
  51         servlist = self.calculate(servcalc,
  52                                   {'min_cores_per_node': 2},
  53                                   {'min_ram_mb_per_node': 256},
  54                                   {'min_nodes': 6},
  55                                   {'min_nodes': 12},
  56                                   {'min_scratch_mb_per_node': 200})
  57         self.assertEqual(6, len(servlist))
  58
  59     def test_ignore_too_expensive_jobs(self):
  60         servcalc = self.make_calculator([1, 2], max_nodes=12, max_price=6)
  61         servlist = self.calculate(servcalc,
  62                                   {'min_cores_per_node': 1, 'min_nodes': 6})
  63         self.assertEqual(6, len(servlist))
  64
  65         servlist = self.calculate(servcalc,
  66                                   {'min_cores_per_node': 2, 'min_nodes': 6})
  67         self.assertEqual(0, len(servlist))
  68
  69     def test_job_requesting_max_nodes_accepted(self):
  70         servcalc = self.make_calculator([1], max_nodes=4)
  71         servlist = self.calculate(servcalc, {'min_nodes': 4})
  72         self.assertEqual(4, len(servlist))
  73
  74     def test_cheapest_size(self):
  75         servcalc = self.make_calculator([2, 4, 1, 3])
  76         self.assertEqual(testutil.MockSize(1), servcalc.cheapest_size())
  77
  78     def test_next_biggest(self):
  79         servcalc = self.make_calculator([1, 2, 4, 8])
  80         servlist = self.calculate(servcalc,
  81                                   {'min_cores_per_node': 3},
  82                                   {'min_cores_per_node': 6})
  83         self.assertEqual([servcalc.cloud_sizes[2].id,
  84                           servcalc.cloud_sizes[3].id],
  85                          [s.id for s in servlist])
  86
  87     def test_multiple_sizes(self):
  88         servcalc = self.make_calculator([1, 2])
  89         servlist = self.calculate(servcalc,
  90                                   {'min_cores_per_node': 2},
  91                                   {'min_cores_per_node': 1},
  92                                   {'min_cores_per_node': 1})
  93         self.assertEqual([servcalc.cloud_sizes[1].id,
  94                           servcalc.cloud_sizes[0].id,
  95                           servcalc.cloud_sizes[0].id],
  96                          [s.id for s in servlist])
  97
  98         servlist = self.calculate(servcalc,
  99                                   {'min_cores_per_node': 1},
 100                                   {'min_cores_per_node': 2},
 101                                   {'min_cores_per_node': 1})
 102         self.assertEqual([servcalc.cloud_sizes[0].id,
 103                           servcalc.cloud_sizes[1].id,
 104                           servcalc.cloud_sizes[0].id],
 105                          [s.id for s in servlist])
 106
 107         servlist = self.calculate(servcalc,
 108                                   {'min_cores_per_node': 1},
 109                                   {'min_cores_per_node': 1},
 110                                   {'min_cores_per_node': 2})
 111         self.assertEqual([servcalc.cloud_sizes[0].id,
 112                           servcalc.cloud_sizes[0].id,
 113                           servcalc.cloud_sizes[1].id],
 114                          [s.id for s in servlist])
 115
 116
 117
 118 class JobQueueMonitorActorTestCase(testutil.RemotePollLoopActorTestMixin,
 119                                    unittest.TestCase):
 120     TEST_CLASS = jobqueue.JobQueueMonitorActor
 121
 122     class MockCalculator(object):
 123         @staticmethod
 124         def servers_for_queue(queue):
 125             return [testutil.MockSize(n) for n in queue]
 126
 127
 128     def build_monitor(self, side_effect, *args, **kwargs):
 129         super(JobQueueMonitorActorTestCase, self).build_monitor(*args, **kwargs)
 130         self.client.jobs().queue().execute.side_effect = side_effect
 131
 132     @mock.patch("subprocess.check_output")
 133     def test_subscribers_get_server_lists(self, mock_squeue):
 134         mock_squeue.return_value = ""
 135
 136         self.build_monitor([{'items': [1, 2]}], self.MockCalculator())
 137         self.monitor.subscribe(self.subscriber).get(self.TIMEOUT)
 138         self.stop_proxy(self.monitor)
 139         self.subscriber.assert_called_with([testutil.MockSize(1),
 140                                             testutil.MockSize(2)])
 141
 142     @mock.patch("subprocess.check_output")
 143     def test_squeue_server_list(self, mock_squeue):
 144         mock_squeue.return_value = """1 0 0 Resources zzzzz-zzzzz-zzzzzzzzzzzzzzy
 145 2 0 0 Resources zzzzz-zzzzz-zzzzzzzzzzzzzzz
 146 """
 147
 148         super(JobQueueMonitorActorTestCase, self).build_monitor(jobqueue.ServerCalculator(
 149             [(testutil.MockSize(n), {'cores': n, 'ram': n, 'scratch': n}) for n in range(1, 3)]))
 150         self.monitor.subscribe(self.subscriber).get(self.TIMEOUT)
 151         self.stop_proxy(self.monitor)
 152         self.subscriber.assert_called_with([testutil.MockSize(1),
 153                                             testutil.MockSize(2)])
 154
 155
 156 if __name__ == '__main__':
 157     unittest.main()