services/nodemanager/tests/testutil.py

   1 #!/usr/bin/env python
   2
   3 from __future__ import absolute_import, print_function
   4
   5 import datetime
   6 import threading
   7 import time
   8
   9 import mock
  10 import pykka
  11
  12 from . import pykka_timeout
  13
  14 no_sleep = mock.patch('time.sleep', lambda n: None)
  15
  16 def arvados_node_mock(node_num=99, job_uuid=None, age=-1, **kwargs):
  17     mod_time = datetime.datetime.utcnow() - datetime.timedelta(seconds=age)
  18     mod_time_s = mod_time.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
  19     if job_uuid is True:
  20         job_uuid = 'zzzzz-jjjjj-jobjobjobjobjob'
  21     crunch_worker_state = 'idle' if (job_uuid is None) else 'busy'
  22     node = {'uuid': 'zzzzz-yyyyy-{:015x}'.format(node_num),
  23             'created_at': '2014-01-01T01:02:03.04050607Z',
  24             'modified_at': mod_time_s,
  25             'first_ping_at': kwargs.pop('first_ping_at', mod_time_s),
  26             'last_ping_at': mod_time_s,
  27             'slot_number': node_num,
  28             'hostname': 'compute{}'.format(node_num),
  29             'domain': 'zzzzz.arvadosapi.com',
  30             'ip_address': ip_address_mock(node_num),
  31             'job_uuid': job_uuid,
  32             'crunch_worker_state': crunch_worker_state,
  33             'properties': {},
  34             'info': {'ping_secret': 'defaulttestsecret'}}
  35     node.update(kwargs)
  36     return node
  37
  38 def cloud_object_mock(name_id, **extra):
  39     # A very generic mock, useful for stubbing libcloud objects we
  40     # only search for and pass around, like locations, subnets, etc.
  41     cloud_object = mock.NonCallableMagicMock(['id', 'name'],
  42                                              name='cloud_object')
  43     cloud_object.name = str(name_id)
  44     cloud_object.id = 'id_' + cloud_object.name
  45     cloud_object.extra = extra
  46     return cloud_object
  47
  48
  49 def cloud_node_fqdn(node):
  50     # We intentionally put the FQDN somewhere goofy to make sure tested code is
  51     # using this function for lookups.
  52     return node.extra.get('testname', 'NoTestName')
  53
  54 def ip_address_mock(last_octet):
  55     return '10.20.30.{}'.format(last_octet)
  56
  57 class MockShutdownTimer(object):
  58     def _set_state(self, is_open, next_opening):
  59         self.window_open = lambda: is_open
  60         self.next_opening = lambda: next_opening
  61
  62
  63 class MockSize(object):
  64     def __init__(self, factor):
  65         self.id = 'z{}.test'.format(factor)
  66         self.name = self.id
  67         self.ram = 128 * factor
  68         self.disk = 100 * factor
  69         self.bandwidth = 16 * factor
  70         self.price = float(factor)
  71         self.extra = {}
  72
  73     def __eq__(self, other):
  74         return self.id == other.id
  75
  76
  77 class MockTimer(object):
  78     def __init__(self, deliver_immediately=True):
  79         self.deliver_immediately = deliver_immediately
  80         self.messages = []
  81         self.lock = threading.Lock()
  82
  83     def deliver(self):
  84         with self.lock:
  85             to_deliver = self.messages
  86             self.messages = []
  87         for callback, args, kwargs in to_deliver:
  88             callback(*args, **kwargs)
  89
  90     def schedule(self, want_time, callback, *args, **kwargs):
  91         with self.lock:
  92             self.messages.append((callback, args, kwargs))
  93         if self.deliver_immediately:
  94             self.deliver()
  95
  96
  97 class ActorTestMixin(object):
  98     FUTURE_CLASS = pykka.ThreadingFuture
  99     TIMEOUT = pykka_timeout
 100
 101     def tearDown(self):
 102         pykka.ActorRegistry.stop_all()
 103
 104     def stop_proxy(self, proxy):
 105         return proxy.actor_ref.stop(timeout=self.TIMEOUT)
 106
 107     def wait_for_assignment(self, proxy, attr_name, unassigned=None,
 108                             timeout=TIMEOUT):
 109         deadline = time.time() + timeout
 110         while True:
 111             loop_timeout = deadline - time.time()
 112             if loop_timeout <= 0:
 113                 self.fail("actor did not assign {} in time".format(attr_name))
 114             result = getattr(proxy, attr_name).get(loop_timeout)
 115             if result is not unassigned:
 116                 return result
 117
 118
 119 class DriverTestMixin(object):
 120     def setUp(self):
 121         self.driver_mock = mock.MagicMock(name='driver_mock')
 122         super(DriverTestMixin, self).setUp()
 123
 124     def new_driver(self, auth_kwargs={}, list_kwargs={}, create_kwargs={}):
 125         create_kwargs.setdefault('ping_host', '100::')
 126         return self.TEST_CLASS(
 127             auth_kwargs, list_kwargs, create_kwargs,
 128             driver_class=self.driver_mock)
 129
 130     def driver_method_args(self, method_name):
 131         return getattr(self.driver_mock(), method_name).call_args
 132
 133
 134 class RemotePollLoopActorTestMixin(ActorTestMixin):
 135     def build_monitor(self, *args, **kwargs):
 136         self.timer = mock.MagicMock(name='timer_mock')
 137         self.client = mock.MagicMock(name='client_mock')
 138         self.subscriber = mock.Mock(name='subscriber_mock')
 139         self.monitor = self.TEST_CLASS.start(
 140             self.client, self.timer, *args, **kwargs).proxy()
 141
 142 def cloud_node_mock(node_num=99, size=MockSize(1), **extra):
 143     node = mock.NonCallableMagicMock(
 144         ['id', 'name', 'state', 'public_ips', 'private_ips', 'driver', 'size',
 145          'image', 'extra'],
 146         name='cloud_node')
 147     node.id = str(node_num)
 148     node.name = node.id
 149     node.size = size
 150     node.public_ips = []
 151     node.private_ips = [ip_address_mock(node_num)]
 152     node.extra = extra
 153     return node