3 from __future__ import absolute_import, print_function
13 import libcloud.common.types as cloud_types
15 from . import pykka_timeout
17 no_sleep = mock.patch('time.sleep', lambda n: None)
19 def arvados_node_mock(node_num=99, job_uuid=None, age=-1, **kwargs):
20 mod_time = datetime.datetime.utcnow() - datetime.timedelta(seconds=age)
21 mod_time_s = mod_time.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
23 job_uuid = 'zzzzz-jjjjj-jobjobjobjobjob'
24 crunch_worker_state = 'idle' if (job_uuid is None) else 'busy'
25 node = {'uuid': 'zzzzz-yyyyy-{:015x}'.format(node_num),
26 'created_at': '2014-01-01T01:02:03.04050607Z',
27 'modified_at': mod_time_s,
28 'first_ping_at': kwargs.pop('first_ping_at', mod_time_s),
29 'last_ping_at': mod_time_s,
30 'slot_number': node_num,
31 'hostname': 'compute{}'.format(node_num),
32 'domain': 'zzzzz.arvadosapi.com',
33 'ip_address': ip_address_mock(node_num),
35 'crunch_worker_state': crunch_worker_state,
37 'info': {'ping_secret': 'defaulttestsecret', 'ec2_instance_id': str(node_num)}}
41 def cloud_object_mock(name_id, **extra):
42 # A very generic mock, useful for stubbing libcloud objects we
43 # only search for and pass around, like locations, subnets, etc.
44 cloud_object = mock.NonCallableMagicMock(['id', 'name'],
46 cloud_object.name = str(name_id)
47 cloud_object.id = 'id_' + cloud_object.name
48 cloud_object.extra = extra
52 def cloud_node_fqdn(node):
53 # We intentionally put the FQDN somewhere goofy to make sure tested code is
54 # using this function for lookups.
55 return node.extra.get('testname', 'NoTestName')
57 def ip_address_mock(last_octet):
58 return '10.20.30.{}'.format(last_octet)
60 @contextlib.contextmanager
61 def redirected_streams(stdout=None, stderr=None):
62 orig_stdout, sys.stdout = sys.stdout, stdout or sys.stdout
63 orig_stderr, sys.stderr = sys.stderr, stderr or sys.stderr
67 sys.stdout = orig_stdout
68 sys.stderr = orig_stderr
71 class MockShutdownTimer(object):
72 def _set_state(self, is_open, next_opening):
73 self.window_open = lambda: is_open
74 self.next_opening = lambda: next_opening
77 class MockSize(object):
78 def __init__(self, factor):
79 self.id = 'z{}.test'.format(factor)
81 self.ram = 128 * factor
82 self.disk = factor # GB
83 self.scratch = 1000 * factor # MB
84 self.bandwidth = 16 * factor
85 self.price = float(factor)
88 def __eq__(self, other):
89 return self.id == other.id
92 class MockTimer(object):
93 def __init__(self, deliver_immediately=True):
94 self.deliver_immediately = deliver_immediately
96 self.lock = threading.Lock()
100 to_deliver = self.messages
102 for callback, args, kwargs in to_deliver:
104 callback(*args, **kwargs)
105 except pykka.ActorDeadError:
108 def schedule(self, want_time, callback, *args, **kwargs):
110 self.messages.append((callback, args, kwargs))
111 if self.deliver_immediately:
115 class ActorTestMixin(object):
116 FUTURE_CLASS = pykka.ThreadingFuture
117 TIMEOUT = pykka_timeout
120 pykka.ActorRegistry.stop_all()
122 def stop_proxy(self, proxy):
123 return proxy.actor_ref.stop(timeout=self.TIMEOUT)
125 def wait_for_assignment(self, proxy, attr_name, unassigned=None,
127 deadline = time.time() + timeout
129 loop_timeout = deadline - time.time()
130 if loop_timeout <= 0:
131 self.fail("actor did not assign {} in time".format(attr_name))
132 result = getattr(proxy, attr_name).get(loop_timeout)
133 if result is not unassigned:
136 def busywait(self, f):
138 while not f() and n < 10:
144 class DriverTestMixin(object):
146 self.driver_mock = mock.MagicMock(name='driver_mock')
147 super(DriverTestMixin, self).setUp()
149 def new_driver(self, auth_kwargs={}, list_kwargs={}, create_kwargs={}):
150 create_kwargs.setdefault('ping_host', '100::')
151 return self.TEST_CLASS(
152 auth_kwargs, list_kwargs, create_kwargs,
153 driver_class=self.driver_mock)
155 def driver_method_args(self, method_name):
156 return getattr(self.driver_mock(), method_name).call_args
158 def test_driver_create_retry(self):
159 with mock.patch('time.sleep'):
160 driver_mock2 = mock.MagicMock(name='driver_mock2')
161 self.driver_mock.side_effect = (Exception("oops"), driver_mock2)
162 kwargs = {'user_id': 'foo'}
163 driver = self.new_driver(auth_kwargs=kwargs)
164 self.assertTrue(self.driver_mock.called)
165 self.assertIs(driver.real, driver_mock2)
167 def test_create_can_find_node_after_timeout(self, create_kwargs={}, node_extra={}):
168 driver = self.new_driver(create_kwargs=create_kwargs)
169 arv_node = arvados_node_mock()
170 cloud_node = cloud_node_mock(**node_extra)
171 cloud_node.name = driver.create_cloud_name(arv_node)
172 create_method = self.driver_mock().create_node
173 create_method.side_effect = cloud_types.LibcloudError("fake timeout")
174 list_method = self.driver_mock().list_nodes
175 list_method.return_value = [cloud_node]
176 actual = driver.create_node(MockSize(1), arv_node)
177 self.assertIs(cloud_node, actual)
179 def test_create_can_raise_exception_after_timeout(self):
180 driver = self.new_driver()
181 arv_node = arvados_node_mock()
182 create_method = self.driver_mock().create_node
183 create_method.side_effect = cloud_types.LibcloudError("fake timeout")
184 list_method = self.driver_mock().list_nodes
185 list_method.return_value = []
186 with self.assertRaises(cloud_types.LibcloudError) as exc_test:
187 driver.create_node(MockSize(1), arv_node)
188 self.assertIs(create_method.side_effect, exc_test.exception)
190 def check_node_found_after_timeout_has_fixed_size(self, size, cloud_node,
192 # This method needs to be called explicitly by driver test suites
194 self.driver_mock().list_sizes.return_value = [size]
195 driver = self.new_driver(create_kwargs=create_kwargs)
196 arv_node = arvados_node_mock()
197 cloud_node.name = driver.create_cloud_name(arv_node)
198 create_method = self.driver_mock().create_node
199 create_method.side_effect = cloud_types.LibcloudError("fake timeout")
200 self.driver_mock().list_nodes.return_value = [cloud_node]
201 actual = driver.create_node(size, arv_node)
202 self.assertIs(size, actual.size)
205 class RemotePollLoopActorTestMixin(ActorTestMixin):
206 def build_monitor(self, *args, **kwargs):
207 self.timer = mock.MagicMock(name='timer_mock')
208 self.client = mock.MagicMock(name='client_mock')
209 self.subscriber = mock.Mock(name='subscriber_mock')
210 self.monitor = self.TEST_CLASS.start(
211 self.client, self.timer, *args, **kwargs).proxy()
213 def cloud_node_mock(node_num=99, size=None, **extra):
215 size = MockSize(node_num)
216 node = mock.NonCallableMagicMock(
217 ['id', 'name', 'state', 'public_ips', 'private_ips', 'driver', 'size',
220 node.id = str(node_num)
224 node.private_ips = [ip_address_mock(node_num)]