sdk/python/tests/arvados_testutil.py

   1 #!/usr/bin/env python
   2
   3 import arvados
   4 import errno
   5 import hashlib
   6 import httplib
   7 import httplib2
   8 import io
   9 import mock
  10 import os
  11 import Queue
  12 import requests
  13 import shutil
  14 import tempfile
  15 import unittest
  16
  17 # Use this hostname when you want to make sure the traffic will be
  18 # instantly refused.  100::/64 is a dedicated black hole.
  19 TEST_HOST = '100::'
  20
  21 skip_sleep = mock.patch('time.sleep', lambda n: None)  # clown'll eat me
  22
  23 def queue_with(items):
  24     """Return a thread-safe iterator that yields the given items.
  25
  26     +items+ can be given as an array or an iterator. If an iterator is
  27     given, it will be consumed to fill the queue before queue_with()
  28     returns.
  29     """
  30     queue = Queue.Queue()
  31     for val in items:
  32         queue.put(val)
  33     return lambda *args, **kwargs: queue.get(block=False)
  34
  35 # fake_httplib2_response and mock_responses
  36 # mock calls to httplib2.Http.request()
  37 def fake_httplib2_response(code, **headers):
  38     headers.update(status=str(code),
  39                    reason=httplib.responses.get(code, "Unknown Response"))
  40     return httplib2.Response(headers)
  41
  42 def mock_responses(body, *codes, **headers):
  43     return mock.patch('httplib2.Http.request', side_effect=queue_with((
  44         (fake_httplib2_response(code, **headers), body) for code in codes)))
  45
  46 # fake_requests_response, mock_get_responses and mock_put_responses
  47 # mock calls to requests.get() and requests.put()
  48 def fake_requests_response(code, body, **headers):
  49     r = requests.Response()
  50     r.status_code = code
  51     r.reason = httplib.responses.get(code, "Unknown Response")
  52     r.headers = headers
  53     r.raw = io.BytesIO(body)
  54     return r
  55
  56 # The following methods patch requests.Session(), where return_value is a mock
  57 # Session object.  The put/get attributes are set on mock Session, and the
  58 # desired put/get behavior is set on the put/get mocks.
  59
  60 def mock_put_responses(body, *codes, **headers):
  61     m = mock.MagicMock()
  62     if isinstance(body, tuple):
  63         codes = list(codes)
  64         codes.insert(0, body)
  65         m.return_value.put.side_effect = queue_with((fake_requests_response(code, b, **headers) for b, code in codes))
  66     else:
  67         m.return_value.put.side_effect = queue_with((fake_requests_response(code, body, **headers) for code in codes))
  68     return mock.patch('requests.Session', m)
  69
  70 def mock_get_responses(body, *codes, **headers):
  71     m = mock.MagicMock()
  72     m.return_value.get.side_effect = queue_with((fake_requests_response(code, body, **headers) for code in codes))
  73     return mock.patch('requests.Session', m)
  74
  75 def mock_get(side_effect):
  76     m = mock.MagicMock()
  77     m.return_value.get.side_effect = side_effect
  78     return mock.patch('requests.Session', m)
  79
  80 def mock_put(side_effect):
  81     m = mock.MagicMock()
  82     m.return_value.put.side_effect = side_effect
  83     return mock.patch('requests.Session', m)
  84
  85 class MockStreamReader(object):
  86     def __init__(self, name='.', *data):
  87         self._name = name
  88         self._data = ''.join(data)
  89         self._data_locators = ['{}+{}'.format(hashlib.md5(d).hexdigest(),
  90                                               len(d)) for d in data]
  91         self.num_retries = 0
  92
  93     def name(self):
  94         return self._name
  95
  96     def readfrom(self, start, size, num_retries=None):
  97         self._readfrom(start, size, num_retries=num_retries)
  98
  99     def _readfrom(self, start, size, num_retries=None):
 100         return self._data[start:start + size]
 101
 102 class ApiClientMock(object):
 103     def api_client_mock(self):
 104         return mock.MagicMock(name='api_client_mock')
 105
 106     def mock_keep_services(self, api_mock=None, status=200, count=12,
 107                            service_type='disk',
 108                            service_host=None,
 109                            service_port=None,
 110                            service_ssl_flag=False):
 111         if api_mock is None:
 112             api_mock = self.api_client_mock()
 113         body = {
 114             'items_available': count,
 115             'items': [{
 116                 'uuid': 'zzzzz-bi6l4-{:015x}'.format(i),
 117                 'owner_uuid': 'zzzzz-tpzed-000000000000000',
 118                 'service_host': service_host or 'keep0x{:x}'.format(i),
 119                 'service_port': service_port or 65535-i,
 120                 'service_ssl_flag': service_ssl_flag,
 121                 'service_type': service_type,
 122             } for i in range(0, count)]
 123         }
 124         self._mock_api_call(api_mock.keep_services().accessible, status, body)
 125         return api_mock
 126
 127     def _mock_api_call(self, mock_method, code, body):
 128         mock_method = mock_method().execute
 129         if code == 200:
 130             mock_method.return_value = body
 131         else:
 132             mock_method.side_effect = arvados.errors.ApiError(
 133                 fake_httplib2_response(code), "{}")
 134
 135
 136 class ArvadosBaseTestCase(unittest.TestCase):
 137     # This class provides common utility functions for our tests.
 138
 139     def setUp(self):
 140         self._tempdirs = []
 141
 142     def tearDown(self):
 143         for workdir in self._tempdirs:
 144             shutil.rmtree(workdir, ignore_errors=True)
 145
 146     def make_tmpdir(self):
 147         self._tempdirs.append(tempfile.mkdtemp())
 148         return self._tempdirs[-1]
 149
 150     def data_file(self, filename):
 151         try:
 152             basedir = os.path.dirname(__file__)
 153         except NameError:
 154             basedir = '.'
 155         return open(os.path.join(basedir, 'data', filename))
 156
 157     def build_directory_tree(self, tree):
 158         tree_root = self.make_tmpdir()
 159         for leaf in tree:
 160             path = os.path.join(tree_root, leaf)
 161             try:
 162                 os.makedirs(os.path.dirname(path))
 163             except OSError as error:
 164                 if error.errno != errno.EEXIST:
 165                     raise
 166             with open(path, 'w') as tmpfile:
 167                 tmpfile.write(leaf)
 168         return tree_root
 169
 170     def make_test_file(self, text="test"):
 171         testfile = tempfile.NamedTemporaryFile()
 172         testfile.write(text)
 173         testfile.flush()
 174         return testfile