def setUp(self):
from kamaki.clients import Client
from kamaki.clients import ClientError as CE
self.endpoint_url = 'http://example.com'
self.token = 's0m370k3n=='
self.client = Client(self.endpoint_url, self.token)
self.CE = CE
class Client(TestCase):
def assert_dicts_are_equal(self, d1, d2):
for k, v in d1.items():
self.assertTrue(k in d2)
if isinstance(v, dict):
self.assert_dicts_are_equal(v, d2[k])
else:
self.assertEqual(unicode(v), unicode(d2[k]))
def setUp(self):
from kamaki.clients import Client
from kamaki.clients import ClientError as CE
self.endpoint_url = 'http://example.com'
self.token = 's0m370k3n=='
self.client = Client(self.endpoint_url, self.token)
self.CE = CE
def tearDown(self):
FR.text = None
FR.status = None
FR.status_code = 200
self.client.token = self.token
def test___init__(self):
self.assertEqual(self.client.endpoint_url, self.endpoint_url)
self.assertEqual(self.client.token, self.token)
self.assert_dicts_are_equal(self.client.headers, {})
DATE_FORMATS = ['%a %b %d %H:%M:%S %Y']
self.assertEqual(self.client.DATE_FORMATS, DATE_FORMATS)
def test__init_thread_limit(self):
exp = 'Nothing set here'
for faulty in (-1, 0.5, 'a string', {}):
self.assertRaises(
AssertionError,
self.client._init_thread_limit,
faulty)
self.assertEqual(exp, getattr(self.client, '_thread_limit', exp))
self.assertEqual(exp, getattr(self.client, '_elapsed_old', exp))
self.assertEqual(exp, getattr(self.client, '_elapsed_new', exp))
self.client._init_thread_limit(42)
self.assertEqual(42, self.client._thread_limit)
self.assertEqual(0.0, self.client._elapsed_old)
self.assertEqual(0.0, self.client._elapsed_new)
def test__watch_thread_limit(self):
waits = (
dict(args=((0.1, 1), (0.1, 2), (0.2, 1), (0.7, 1), (0.3, 2))),
dict(args=((1.0 - (i / 10.0), (i + 1)) for i in range(7))),
dict(max=1, args=tuple([(randint(1, 10) / 3.0, 1), ] * 10)),
dict(
limit=5,
args=tuple([
(1.0 + (i / 10.0), (5 - i - 1)) for i in range(4)] + [
(2.0, 1), (1.9, 2), (2.0, 1), (2.0, 2)])),
dict(args=tuple(
[(1.0 - (i / 10.0), (i + 1)) for i in range(7)] + [
(0.1, 7), (0.2, 6), (0.4, 5), (0.3, 6), (0.2, 7), (0.1, 7)])),)
for wait_dict in waits:
if 'max' in wait_dict:
self.client.MAX_THREADS = wait_dict['max']
else:
self.client.MAX_THREADS = 7
if 'limit' in wait_dict:
self.client._init_thread_limit(wait_dict['limit'])
else:
self.client._init_thread_limit()
self.client._watch_thread_limit(list())
self.assertEqual(1, self.client._thread_limit)
for wait, exp_limit in wait_dict['args']:
self.client._elapsed_new = wait
self.client._watch_thread_limit(list())
self.assertEqual(exp_limit, self.client._thread_limit)
@patch('kamaki.clients.Client.set_header')
def test_set_header(self, SH):
for name, value, condition in product(
('n4m3', '', None),
('v41u3', None, 42),
(True, False, None, 1, '')):
self.client.set_header(name, value, iff=condition)
self.assertEqual(
SH.mock_calls[-1], call(name, value, iff=condition))
@patch('kamaki.clients.Client.set_param')
def test_set_param(self, SP):
for name, value, condition in product(
('n4m3', '', None),
('v41u3', None, 42),
(True, False, None, 1, '')):
self.client.set_param(name, value, iff=condition)
self.assertEqual(
SP.mock_calls[-1], call(name, value, iff=condition))
@patch('kamaki.clients.RequestManager', return_value=FR)
@patch('kamaki.clients.ResponseManager', return_value=FakeResp())
@patch('kamaki.clients.ResponseManager.__init__')
def test_request(self, Requ, RespInit, Resp):
for args in product(
('get', '', dict(method='get')),
('/some/path', None, ['some', 'path']),
(dict(), dict(h1='v1'), dict(h1='v2', h2='v2')),
(dict(), dict(p1='v1'), dict(p1='v2', p2=None, p3='v3')),
(dict(), dict(data='some data'), dict(
success=400,
json=dict(k2='v2', k1='v1')))):
method, path, kwargs = args[0], args[1], args[-1]
FakeResp.status_code = kwargs.get('success', 200)
if not (method and (
isinstance(method, str) or isinstance(
method, unicode)) and (
isinstance(path, str) or isinstance(path, unicode))):
self.assertRaises(
AssertionError, self.client.request, method, path,
**kwargs)
continue
self.client.request(method, path, **kwargs)
self.assertEqual(
RespInit.mock_calls[-1],
call(FR, connection_retry_limit=0, poolsize=None))
@patch('kamaki.clients.Client.request', return_value='lala')
def _test_foo(self, foo, request):
method = getattr(self.client, foo)
r = method('path', k='v')
self.assertEqual(r, 'lala')
request.assert_called_once_with(foo, 'path', k='v')
def test_delete(self):
self._test_foo('delete')
def test_get(self):
self._test_foo('get')
def test_head(self):
self._test_foo('head')
def test_post(self):
self._test_foo('post')
def test_put(self):
self._test_foo('put')
def test_copy(self):
self._test_foo('copy')
def test_move(self):
self._test_foo('move')
