def list_keys(self, prefix=None, after=None, limit=None) -> Response: """ Used to get a list of keys matching a certain prefix. @param prefix: specifies what you want to get a list of. @param after: the item specified as a return value from this function last time you called it. @param limit: defaults to 1000 keys returned. @return: Response within key_count, next_after, and keys. """ kwargs = {'domain': self._domain} if prefix is not None: kwargs['prefix'] = prefix if after is not None: kwargs['after'] = after if limit is not None: kwargs['limit'] = limit try: return self._do_request(backend.ListKeysConfig, **kwargs) except Exception as exception: if exception.code == 'none_match': # Empty result set from this list call should not result # in an exception. Return a mocked Mogile response instead. response = Response('OK \r\n', backend.ListKeysConfig) response.data = { 'key_count': 0, 'next_after': None, 'keys': {}, } return response raise exception
def test_set_state(self): return_value = Response('OK \r\n', SetStateConfig) with patch.object(Backend, 'do_request', return_value=return_value): response = Backend([]).set_state(host='localhost', device=7, state='down').data self.assertEqual(response, {})
def test_set_weight(self): return_value = Response('OK \r\n', SetWeightConfig) with patch.object(Backend, 'do_request', return_value=return_value): response = Backend([]).set_weight(host='testhost10', device=6, weight=8).data self.assertEqual(response, {})
def test_delete_class(self): return_value = Response('OK domain=testdomain&class=testclass\r\n', DeleteClassConfig) with patch.object(Backend, 'do_request', return_value=return_value): classes = Backend([]).delete_class('testdomain', 'testclass').data expected = {'domain': 'testdomain', 'class': 'testclass'} self.assertEqual(classes, expected)
def test_create_device(self): return_value = Response('OK \r\n', CreateDeviceConfig) with patch.object(Backend, 'do_request', return_value=return_value): response = Backend([]).create_device(hostname='testhost10', devid=6, hostip='0.0.0.0', state='alive').data self.assertEqual(response, {})
def test_update_host(self): return_value = Response('OK hostid=7&hostname=hostname\r\n', UpdateHostConfig) with patch.object(Backend, 'do_request', return_value=return_value): response = Backend([]).update_host(host='localhost', ip='0.0.0.0', port=7001).data expected = {'id': '7', 'name': 'hostname'} self.assertEqual(response, expected)
def test_get_domains(self): return_value = Response( 'OK domain15class1name=default&domain25class1' 'name=default&domain41class1mindevcount=2\r\n', GetDomainsConfig) with patch.object(Backend, 'do_request', return_value=return_value): domains = Backend([]).get_domains().data['domains'] self.assertEqual(domains[15]['classes'][1]['name'], 'default') self.assertEqual(domains[25]['classes'][1]['name'], 'default') self.assertEqual(domains[41]['classes'][1]['mindevcount'], '2')
def test_parse_response_text(self): response = Response( 'OK host6_hostip=10.0.0.25&' 'host6_http_port=7500&host8_hostname=\r\n', GetHostsConfig) expected = [{ 'hostip': '10.0.0.25', 'http_port': '7500' }, { 'hostname': '' }] self.assertIn(expected[0], response.data['hosts'].values()) self.assertIn(expected[1], response.data['hosts'].values())
def list_keys(self, prefix=None, after=None, limit=None): kwargs = {'domain': self._domain} if prefix is not None: kwargs['prefix'] = prefix if after is not None: kwargs['after'] = after if limit is not None: kwargs['limit'] = limit try: return self._do_request(backend.ListKeysConfig, **kwargs) except Exception as exception: if exception.code == 'none_match': # Empty result set from this list call should not result # in an exception. Return a mocked Mogile response instead. response = Response('OK \r\n', backend.ListKeysConfig) response.data = { 'key_count': 0, 'next_after': None, 'keys': {}, } return response raise exception
def test_get_file(self): class FakeResponse: raw = io.BytesIO(b'foo\r\n') return_value = Response( 'OK path1=http://10.0.0.2:7500/dev38/0/056/25' '4/0056254995.fid&paths=2&path2=http://10.0.0' '.1:7500/dev54/0/056/254/0056254995.fid\r\n', GetPathsConfig) with patch.object(requests, 'get', return_value=FakeResponse): with patch.object(Client, 'get_paths', return_value=return_value): client = Client([], 'domain') key = 'test_file_0.634434876753_1480606271.32_4' buf = client.get_file(key=key) self.assertEqual(buf.read(), b'foo\r\n')
def test_get_devices_with_devices(self): return_value = Response( 'OK dev27_mb_asof=&dev27_mb_total=1870562&dev' '26_mb_used=76672&devices=6\r\n', GetDevicesConfig) with patch.object(Backend, 'do_request', return_value=return_value): devices = Backend([]).get_devices().data expected = [{ 'mb_asof': '', 'mb_total': '1870562' }, { 'mb_used': '76672' }] self.assertIn(expected[0], devices['devices'].values()) self.assertIn(expected[1], devices['devices'].values())
def test_update_class(self): return_value = Response( 'OK mindevcount=3&domain=testdomain&class=tes' 'tclass\r\n', CreateClassConfig) with patch.object(Backend, 'do_request', return_value=return_value): classes = Backend([]).update_class(domain='testdomain', _class='testclass', mindevcount=3).data expected = { 'mindevcount': '3', 'domain': 'testdomain', 'class': 'testclass' } self.assertEqual(expected, classes)
def test_get_paths(self): return_value = Response( 'OK path1=http://10.0.0.2:7500/dev38/0/056/25' '4/0056254995.fid&paths=2&path2=http://10.0.0' '.1:7500/dev54/0/056/254/0056254995.fid\r\n', GetPathsConfig) with patch.object(Backend, 'do_request', return_value=return_value): client = Client([], 'domain') key = 'test_file_0.634434876753_1480606271.32_4' response = client.get_paths(key=key).data self.assertEqual(response['path_count'], 2) path_1 = 'http://10.0.0.2:7500/dev38/0/056/254/0056254995.fid' self.assertIn((1, path_1), response['paths'].items()) path_2 = 'http://10.0.0.1:7500/dev54/0/056/254/0056254995.fid' self.assertIn((2, path_2), response['paths'].items())
def test_list_keys_no_arguments(self): return_value = Response( 'OK key_3=test_file_0.0129341319339_148060608' '0.74&key_21=test_file_0.634434876753_1480606' '271.32_4&key_count=666&next_after=after\r\n', ListKeysConfig) with patch.object(Backend, 'do_request', return_value=return_value): client = Client([], 'domain') response = client.list_keys().data self.assertEqual(response['key_count'], 666) self.assertEqual(response['next_after'], 'after') self.assertIn((3, 'test_file_0.0129341319339_1480606080.74'), response['keys'].items()) self.assertIn((21, 'test_file_0.634434876753_1480606271.32_4'), response['keys'].items())
def test_store_file(self): # fake_put is used to read the full contents of `data`, in order for # Client.store_file to return the correct position in the file_handle # through seek(). def fake_put(path, data, timeout=None): data.read() create_open = Response( 'OK paths=1&path_1=http://10.0.0.1:7500/dev1/0' '/1/2/0000000001.fid&fid=56320928&dev_count=1&' 'devid_1=57\r\n', CreateOpenConfig) create_close = Response('OK \r\n', CreateCloseConfig) with patch.object(Client, '_create_open', return_value=create_open), \ patch.object(Client, '_create_close', return_value=create_close), \ patch('requests.put', new=fake_put): client = Client([], 'domain') file_handle = io.BytesIO(b'asdf') response = client.store_file(file_handle=file_handle, key='testkey', _class='testclass') self.assertEqual(response['length'], 4) self.assertEqual(response['path'], 'http://10.0.0.1:7500/dev1/0/1/2/0000000001.fid')
def test_get_hosts_with_hosts(self): return_value = Response( 'OK host6_hostip=10.0.0.25&host6_http_port=75' '00&host8_hostname=&hosts=10\r\n', GetHostsConfig) with patch.object(Backend, 'do_request', return_value=return_value): hosts = Backend([]).get_hosts().data expected = [{ 'hostip': '10.0.0.25', 'http_port': '7500' }, { 'hostname': '' }] self.assertIn(expected[0], hosts['hosts'].values()) self.assertIn(expected[1], hosts['hosts'].values())
def test_get_file_no_paths(self): return_value = Response('OK paths=0\r\n', GetPathsConfig) with patch.object(Backend, 'do_request', return_value=return_value): with self.assertRaises(FileNotFoundError): Client([], 'domain').get_file(key='doesnotexist')
def do_request(self, request): assert isinstance(request, Request) self._sock.send(bytes(request)) response_text = self._recv_all() self._sock.close() return Response(response_text, request.config)
def test_delete_domain(self): return_value = Response('OK domain=testdomain\r\n', DeleteDomainConfig) with patch.object(Backend, 'do_request', return_value=return_value): domains = Backend([]).delete_domain('testdomain').data expected = {'domain': 'testdomain'} self.assertEqual(domains, expected)
def test_delete_host(self): return_value = Response('OK \r\n', DeleteHostConfig) with patch.object(Backend, 'do_request', return_value=return_value): response = Backend([]).delete_host(host='localhost').data self.assertEqual(response, {})
def test_instantiate_with_error(self): response_text = 'ERR unknown_command Unknown+server+command\r\n' with self.assertRaises(MogilefsError): Response(response_text, GetHostsConfig)
def test_instantiate_with_str(self): response_text = 'OK host1_hostip=10.0.0.25' Response(response_text, GetHostsConfig)