Revision 4443152f
| b/kamaki/clients/compute/test.py | ||
|---|---|---|
| 314 | 314 |
def test_create_server_metadata(self, SP): |
| 315 | 315 |
vm_id = vm_recv['server']['id'] |
| 316 | 316 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| 317 |
FR.json = dict(metadata=vm_recv['server'])
|
|
| 317 |
FR.json = dict(meta=vm_recv['server']) |
|
| 318 | 318 |
for k, v in metadata.items(): |
| 319 | 319 |
r = self.client.create_server_metadata(vm_id, k, v) |
| 320 | 320 |
self.assert_dicts_are_equal(r, vm_recv['server']) |
| 321 | 321 |
self.assertEqual(SP.mock_calls[-1], call( |
| 322 | 322 |
vm_id, 'metadata/%s' % k, |
| 323 |
json_data=dict(metadata={k: v}), success=201))
|
|
| 323 |
json_data=dict(meta={k: v}), success=201))
|
|
| 324 | 324 |
|
| 325 | 325 |
@patch('%s.servers_get' % compute_pkg, return_value=FR())
|
| 326 | 326 |
def test_get_server_metadata(self, SG): |
| ... | ... | |
| 328 | 328 |
metadata = dict(m1='v1', m2='v2', m3='v3') |
| 329 | 329 |
FR.json = dict(metadata=metadata) |
| 330 | 330 |
r = self.client.get_server_metadata(vm_id) |
| 331 |
FR.json = dict(meta=metadata) |
|
| 331 | 332 |
SG.assert_called_once_with(vm_id, '/metadata') |
| 332 | 333 |
self.assert_dicts_are_equal(r, metadata) |
| 333 | 334 |
|
| 334 | 335 |
for k, v in metadata.items(): |
| 335 |
FR.json = dict(metadata={k: v})
|
|
| 336 |
FR.json = dict(meta={k: v})
|
|
| 336 | 337 |
r = self.client.get_server_metadata(vm_id, k) |
| 337 | 338 |
self.assert_dicts_are_equal(r, {k: v})
|
| 338 | 339 |
self.assertEqual( |
| ... | ... | |
| 391 | 392 |
@patch('%s.images_get' % compute_pkg, return_value=FR())
|
| 392 | 393 |
def test_get_image_metadata(self, IG): |
| 393 | 394 |
for key in ('', '50m3k3y'):
|
| 394 |
FR.json = dict(metadata=img_recv['image']) if (
|
|
| 395 |
FR.json = dict(meta=img_recv['image']) if ( |
|
| 395 | 396 |
key) else dict(metadata=img_recv['image']) |
| 396 | 397 |
r = self.client.get_image_metadata(img_ref, key) |
| 397 | 398 |
self.assertEqual(IG.mock_calls[-1], call( |
| ... | ... | |
| 413 | 414 |
@patch('%s.images_put' % compute_pkg, return_value=FR())
|
| 414 | 415 |
def test_create_image_metadata(self, IP): |
| 415 | 416 |
(key, val) = ('k1', 'v1')
|
| 416 |
FR.json = dict(metadata=img_recv['image'])
|
|
| 417 |
FR.json = dict(meta=img_recv['image']) |
|
| 417 | 418 |
r = self.client.create_image_metadata(img_ref, key, val) |
| 418 | 419 |
IP.assert_called_once_with( |
| 419 | 420 |
img_ref, 'metadata/%s' % key, |
| 420 |
json_data=dict(metadata={key: val}))
|
|
| 421 |
json_data=dict(meta={key: val}))
|
|
| 421 | 422 |
self.assert_dicts_are_equal(r, img_recv['image']) |
| 422 | 423 |
|
| 423 | 424 |
@patch('%s.images_post' % compute_pkg, return_value=FR())
|
| b/kamaki/clients/cyclades/test.py | ||
|---|---|---|
| 354 | 354 |
@patch('%s.servers_get' % cyclades_pkg, return_value=FR())
|
| 355 | 355 |
def test_list_server_nics(self, SG): |
| 356 | 356 |
vm_id = vm_recv['server']['id'] |
| 357 |
nics = dict(addresses=[dict(id='nic1'), dict(id='nic2')])
|
|
| 357 |
nics = dict(attachments=[dict(id='nic1'), dict(id='nic2')])
|
|
| 358 | 358 |
FR.json = nics |
| 359 | 359 |
r = self.client.list_server_nics(vm_id) |
| 360 | 360 |
SG.assert_called_once_with(vm_id, 'ips') |
| 361 |
expected = nics['addresses']
|
|
| 361 |
expected = nics['attachments']
|
|
| 362 | 362 |
for i in range(len(r)): |
| 363 | 363 |
self.assert_dicts_are_equal(r[i], expected[i]) |
| 364 | 364 |
self.assertEqual(i + 1, len(r)) |
| b/kamaki/clients/livetest/__init__.py | ||
|---|---|---|
| 135 | 135 |
self.assertEqual(v, d2[k]) |
| 136 | 136 |
|
| 137 | 137 |
def assert_dicts_are_deeply_equal(self, d1, d2): |
| 138 |
(st1, st2) = (set(d1.keys()), set(d2.keys())) |
|
| 138 |
st1 = set([unicode(k) for k in d1]) |
|
| 139 |
st2 = set([unicode(k) for k in d2]) |
|
| 139 | 140 |
diff1 = st1.difference(st2) |
| 140 | 141 |
diff2 = st2.difference(st1) |
| 141 | 142 |
self.assertTrue( |
| b/kamaki/clients/livetest/astakos.py | ||
|---|---|---|
| 116 | 116 |
self._test_0020_get() |
| 117 | 117 |
|
| 118 | 118 |
def _test_0020_get(self): |
| 119 |
for term in ('id', 'name', 'roles'):
|
|
| 119 |
for term in ('id', 'name'):
|
|
| 120 | 120 |
self.assertEqual( |
| 121 | 121 |
self.client.term(term, self[self.cloud, 'token']), |
| 122 |
self['astakos', term] or ([] if term == 'roles' else ''))
|
|
| 122 |
self['astakos', term] or '')
|
|
| 123 | 123 |
|
| 124 | 124 |
def test_list_users(self): |
| 125 | 125 |
self.client.authenticate() |
| b/kamaki/clients/livetest/cyclades.py | ||
|---|---|---|
| 88 | 88 |
|
| 89 | 89 |
def _create_server(self, servername, flavorid, imageid, personality=None): |
| 90 | 90 |
server = self.client.create_server( |
| 91 |
servername, |
|
| 92 |
flavorid, |
|
| 93 |
imageid, |
|
| 94 |
personality) |
|
| 91 |
servername, flavorid, imageid, personality) |
|
| 95 | 92 |
print('CREATE VM %s (%s)' % (server['id'], server['name']))
|
| 96 | 93 |
self.servers[servername] = server |
| 97 | 94 |
return server |
| ... | ... | |
| 241 | 238 |
|
| 242 | 239 |
def _test_0010_create_server(self): |
| 243 | 240 |
self.assertEqual(self.server1["name"], self.servname1) |
| 244 |
self.assertEqual(self.server1["flavor"], self.flavorid) |
|
| 245 |
self.assertEqual(self.server1["image"], self.img) |
|
| 241 |
self.assertEqual(self.server1["flavor"]["id"], self.flavorid)
|
|
| 242 |
self.assertEqual(self.server1["image"]["id"], self.img)
|
|
| 246 | 243 |
self.assertEqual(self.server1["status"], "BUILD") |
| 247 | 244 |
|
| 248 | 245 |
def test_list_servers(self): |
| ... | ... | |
| 298 | 295 |
def _test_0040_get_server_details(self): |
| 299 | 296 |
r = self.client.get_server_details(self.server1['id']) |
| 300 | 297 |
self.assertEqual(r["name"], self.servname1) |
| 301 |
self.assertEqual(r["flavor"], self.flavorid) |
|
| 302 |
self.assertEqual(r["image"], self.img) |
|
| 298 |
self.assertEqual(r["flavor"]["id"], self.flavorid)
|
|
| 299 |
self.assertEqual(r["image"]["id"], self.img)
|
|
| 303 | 300 |
self.assertEqual(r["status"], "ACTIVE") |
| 304 | 301 |
|
| 305 | 302 |
def test_update_server_name(self): |
| ... | ... | |
| 364 | 361 |
'mymeta val') |
| 365 | 362 |
self.assertTrue('mymeta' in r1)
|
| 366 | 363 |
r2 = self.client.get_server_metadata(self.server1['id'], 'mymeta') |
| 367 |
self.assert_dicts_are_deeply_equal(r1, r2)
|
|
| 364 |
self.assert_dicts_are_equal(r1, r2) |
|
| 368 | 365 |
|
| 369 | 366 |
def test_get_server_metadata(self): |
| 370 | 367 |
"""Test get server_metadata""" |
| ... | ... | |
| 429 | 426 |
|
| 430 | 427 |
def _test_0130_get_flavor_details(self): |
| 431 | 428 |
r = self.client.get_flavor_details(self.flavorid) |
| 432 |
self.assert_dicts_are_deeply_equal(self._flavor_details, r)
|
|
| 429 |
self.assert_dicts_are_equal(self._flavor_details, r) |
|
| 433 | 430 |
|
| 434 |
def test_list_images(self): |
|
| 435 |
"""Test list_images""" |
|
| 436 |
self._test_0140_list_images() |
|
| 431 |
#def test_list_images(self):
|
|
| 432 |
# """Test list_images"""
|
|
| 433 |
# self._test_0140_list_images()
|
|
| 437 | 434 |
|
| 438 |
def _test_0140_list_images(self): |
|
| 439 |
r = self.client.list_images() |
|
| 440 |
self.assertTrue(len(r) > 1) |
|
| 441 |
r = self.client.list_images(detail=True) |
|
| 442 |
for detailed_img in r: |
|
| 443 |
if detailed_img['id'] == self.img: |
|
| 444 |
break |
|
| 445 |
self.assert_dicts_are_deeply_equal(detailed_img, self.img_details)
|
|
| 435 |
#def _test_0140_list_images(self):
|
|
| 436 |
# r = self.client.list_images()
|
|
| 437 |
# self.assertTrue(len(r) > 1)
|
|
| 438 |
# r = self.client.list_images(detail=True)
|
|
| 439 |
# for detailed_img in r:
|
|
| 440 |
# if detailed_img['id'] == self.img:
|
|
| 441 |
# break
|
|
| 442 |
# self.assert_dicts_are_equal(detailed_img, self.img_details)
|
|
| 446 | 443 |
|
| 447 | 444 |
def test_get_image_details(self): |
| 448 | 445 |
"""Test image_details""" |
| ... | ... | |
| 450 | 447 |
|
| 451 | 448 |
def _test_0150_get_image_details(self): |
| 452 | 449 |
r = self.client.get_image_details(self.img) |
| 453 |
self.assert_dicts_are_deeply_equal(r, self.img_details)
|
|
| 450 |
self.assert_dicts_are_equal(r, self.img_details) |
|
| 454 | 451 |
|
| 455 | 452 |
def test_get_image_metadata(self): |
| 456 | 453 |
"""Test get_image_metadata""" |
| ... | ... | |
| 458 | 455 |
|
| 459 | 456 |
def _test_0160_get_image_metadata(self): |
| 460 | 457 |
r = self.client.get_image_metadata(self.img) |
| 461 |
self.assert_dicts_are_deeply_equal(
|
|
| 458 |
self.assert_dicts_are_equal( |
|
| 462 | 459 |
self.img_details['metadata'], r) |
| 463 | 460 |
for key, val in self.img_details['metadata'].items(): |
| 464 | 461 |
r = self.client.get_image_metadata(self.img, key) |
| ... | ... | |
| 592 | 589 |
chosen.pop('updated')
|
| 593 | 590 |
net1 = dict(self.network1) |
| 594 | 591 |
net1.pop('updated')
|
| 595 |
self.assert_dicts_are_deeply_equal(chosen, net1)
|
|
| 592 |
self.assert_dicts_are_equal(chosen, net1) |
|
| 596 | 593 |
full_args = dict( |
| 597 | 594 |
cidr='192.168.1.0/24', |
| 598 | 595 |
gateway='192.168.1.1', |
| ... | ... | |
| 735 | 732 |
r.pop('status')
|
| 736 | 733 |
r.pop('updated', None)
|
| 737 | 734 |
r.pop('attachments')
|
| 738 |
self.assert_dicts_are_deeply_equal(net1, r)
|
|
| 735 |
self.assert_dicts_are_equal(net1, r) |
|
| 739 | 736 |
|
| 740 | 737 |
def test_update_network_name(self): |
| 741 | 738 |
self.network2 = self._create_network(self.netname2) |
| b/kamaki/clients/pithos/test.py | ||
|---|---|---|
| 1422 | 1422 |
GAI.assert_called_once_with() |
| 1423 | 1423 |
self.assertEqual(r[key], account_info[key]) |
| 1424 | 1424 |
|
| 1425 |
@patch('%s.get_account_info' % pithos_pkg, return_value=account_info)
|
|
| 1426 |
def test_get_account_versioning(self, GAI): |
|
| 1427 |
key = 'x-account-policy-versioning' |
|
| 1428 |
r = self.client.get_account_versioning() |
|
| 1429 |
GAI.assert_called_once_with() |
|
| 1430 |
self.assertEqual(r[key], account_info[key]) |
|
| 1425 |
#@patch('%s.get_account_info' % pithos_pkg, return_value=account_info)
|
|
| 1426 |
#def test_get_account_versioning(self, GAI):
|
|
| 1427 |
# key = 'x-account-policy-versioning'
|
|
| 1428 |
# r = self.client.get_account_versioning()
|
|
| 1429 |
# GAI.assert_called_once_with()
|
|
| 1430 |
# self.assertEqual(r[key], account_info[key])
|
|
| 1431 | 1431 |
|
| 1432 | 1432 |
def test_get_account_meta(self): |
| 1433 | 1433 |
key = 'x-account-meta-' |
| ... | ... | |
| 1473 | 1473 |
self.client.set_account_meta(metas) |
| 1474 | 1474 |
post.assert_called_once_with(update=True, metadata=metas) |
| 1475 | 1475 |
|
| 1476 |
""" |
|
| 1477 |
@patch('%s.account_post' % pithos_pkg, return_value=FR())
|
|
| 1478 |
def test_set_account_quota(self, post): |
|
| 1479 |
qu = 1024 |
|
| 1480 |
self.client.set_account_quota(qu) |
|
| 1481 |
post.assert_called_once_with(update=True, quota=qu) |
|
| 1482 |
""" |
|
| 1476 |
#@patch('%s.account_post' % pithos_pkg, return_value=FR())
|
|
| 1477 |
#def test_set_account_quota(self, post): |
|
| 1478 |
# qu = 1024 |
|
| 1479 |
# self.client.set_account_quota(qu) |
|
| 1480 |
# post.assert_called_once_with(update=True, quota=qu) |
|
| 1483 | 1481 |
|
| 1484 |
@patch('%s.account_post' % pithos_pkg, return_value=FR())
|
|
| 1485 |
def test_set_account_versioning(self, post): |
|
| 1486 |
vrs = 'n3wV3r51on1ngTyp3' |
|
| 1487 |
self.client.set_account_versioning(vrs) |
|
| 1488 |
post.assert_called_once_with(update=True, versioning=vrs) |
|
| 1482 |
#@patch('%s.account_post' % pithos_pkg, return_value=FR())
|
|
| 1483 |
#def test_set_account_versioning(self, post):
|
|
| 1484 |
# vrs = 'n3wV3r51on1ngTyp3'
|
|
| 1485 |
# self.client.set_account_versioning(vrs)
|
|
| 1486 |
# post.assert_called_once_with(update=True, versioning=vrs)
|
|
| 1489 | 1487 |
|
| 1490 | 1488 |
@patch('%s.container_delete' % pithos_pkg, return_value=FR())
|
| 1491 | 1489 |
def test_del_container(self, delete): |
| ... | ... | |
| 1601 | 1599 |
def test_publish_object(self, post): |
| 1602 | 1600 |
oinfo = dict(object_info) |
| 1603 | 1601 |
val = 'pubL1c' |
| 1604 |
oinfo['x-object-public'] = val |
|
| 1602 |
oinfo['x-object-public'] = 'https://www.example.com/' + val
|
|
| 1605 | 1603 |
with patch.object( |
| 1606 | 1604 |
pithos.PithosClient, 'get_object_info', |
| 1607 | 1605 |
return_value=oinfo) as GOF: |
| b/kamaki/clients/test.py | ||
|---|---|---|
| 138 | 138 |
HEADERS = dict(k='v', k1='v1', k2='v2') |
| 139 | 139 |
reason = 'some reason' |
| 140 | 140 |
status = 42 |
| 141 |
status_code = 200 |
|
| 141 | 142 |
|
| 142 | 143 |
def read(self): |
| 143 | 144 |
return self.READ |
| ... | ... | |
| 271 | 272 |
status_code = 200 |
| 272 | 273 |
|
| 273 | 274 |
|
| 274 |
class FakeConnection(object): |
|
| 275 |
"""A fake Connection class""" |
|
| 276 |
|
|
| 277 |
headers = dict() |
|
| 278 |
params = dict() |
|
| 279 |
|
|
| 280 |
def __init__(self): |
|
| 281 |
pass |
|
| 282 |
|
|
| 283 |
def set_header(self, name, value): |
|
| 284 |
pass |
|
| 285 |
|
|
| 286 |
def reset_headers(self): |
|
| 287 |
self.headers = {}
|
|
| 288 |
|
|
| 289 |
def set_param(self, name, value): |
|
| 290 |
self.params = {}
|
|
| 291 |
|
|
| 292 |
def reset_params(self): |
|
| 293 |
pass |
|
| 294 |
|
|
| 295 |
def perform_request(self, *args): |
|
| 296 |
return FR() |
|
| 297 |
|
|
| 298 |
|
|
| 299 | 275 |
class Client(TestCase): |
| 300 | 276 |
|
| 301 | 277 |
def assert_dicts_are_equal(self, d1, d2): |
| ... | ... | |
| 311 | 287 |
from kamaki.clients import ClientError as CE |
| 312 | 288 |
self.base_url = 'http://example.com' |
| 313 | 289 |
self.token = 's0m370k3n==' |
| 314 |
self.client = Client(self.base_url, self.token, FakeConnection())
|
|
| 290 |
self.client = Client(self.base_url, self.token) |
|
| 315 | 291 |
self.CE = CE |
| 316 | 292 |
|
| 317 | 293 |
def tearDown(self): |
| 318 | 294 |
FR.text = None |
| 319 | 295 |
FR.status = None |
| 320 | 296 |
FR.status_code = 200 |
| 321 |
FakeConnection.headers = dict() |
|
| 322 | 297 |
self.client.token = self.token |
| 323 | 298 |
|
| 324 | 299 |
def test___init__(self): |
| ... | ... | |
| 330 | 305 |
'%A, %d-%b-%y %H:%M:%S GMT', |
| 331 | 306 |
'%a, %d %b %Y %H:%M:%S GMT'] |
| 332 | 307 |
self.assertEqual(self.client.DATE_FORMATS, DATE_FORMATS) |
| 333 |
self.assertTrue(isinstance(self.client.http_client, FakeConnection)) |
|
| 334 | 308 |
|
| 335 | 309 |
def test__init_thread_limit(self): |
| 336 | 310 |
exp = 'Nothing set here' |
| ... | ... | |
| 394 | 368 |
self.assertEqual('%s' % ce, '%s %s\n' % (sts_code or '', msg))
|
| 395 | 369 |
self.assertEqual(ce.status, sts_code or 0) |
| 396 | 370 |
|
| 397 |
@patch('%s.FakeConnection.set_header' % __name__)
|
|
| 371 |
@patch('kamaki.clients.Client.set_header')
|
|
| 398 | 372 |
def test_set_header(self, SH): |
| 399 |
num_of_calls = 0 |
|
| 400 | 373 |
for name, value, condition in product( |
| 401 | 374 |
('n4m3', '', None),
|
| 402 | 375 |
('v41u3', None, 42),
|
| 403 | 376 |
(True, False, None, 1, '')): |
| 404 | 377 |
self.client.set_header(name, value, iff=condition) |
| 405 |
if value is not None and condition: |
|
| 406 |
self.assertEqual(SH.mock_calls[-1], call(name, value)) |
|
| 407 |
num_of_calls += 1 |
|
| 408 |
else: |
|
| 409 |
self.assertEqual(num_of_calls, len(SH.mock_calls)) |
|
| 378 |
self.assertEqual( |
|
| 379 |
SH.mock_calls[-1], call(name, value, iff=condition)) |
|
| 410 | 380 |
|
| 411 |
@patch('%s.FakeConnection.set_param' % __name__)
|
|
| 381 |
@patch('kamaki.clients.Client.set_param')
|
|
| 412 | 382 |
def test_set_param(self, SP): |
| 413 |
num_of_calls = 0 |
|
| 414 | 383 |
for name, value, condition in product( |
| 415 | 384 |
('n4m3', '', None),
|
| 416 | 385 |
('v41u3', None, 42),
|
| 417 | 386 |
(True, False, None, 1, '')): |
| 418 | 387 |
self.client.set_param(name, value, iff=condition) |
| 419 |
if condition: |
|
| 420 |
self.assertEqual(SP.mock_calls[-1], call(name, value)) |
|
| 421 |
num_of_calls += 1 |
|
| 422 |
else: |
|
| 423 |
self.assertEqual(num_of_calls, len(SP.mock_calls)) |
|
| 388 |
self.assertEqual( |
|
| 389 |
SP.mock_calls[-1], call(name, value, iff=condition)) |
|
| 424 | 390 |
|
| 425 |
@patch('%s.FakeConnection.perform_request' % __name__, return_value=FR())
|
|
| 426 |
def test_request(self, PR): |
|
| 391 |
@patch('kamaki.clients.RequestManager', return_value=FR)
|
|
| 392 |
@patch('kamaki.clients.ResponseManager', return_value=FakeResp())
|
|
| 393 |
@patch('kamaki.clients.ResponseManager.__init__')
|
|
| 394 |
def test_request(self, Requ, RespInit, Resp): |
|
| 427 | 395 |
for args in product( |
| 428 | 396 |
('get', '', dict(method='get')),
|
| 429 | 397 |
('/some/path', None, ['some', 'path']),
|
| ... | ... | |
| 433 | 401 |
success=400, |
| 434 | 402 |
json=dict(k2='v2', k1='v1')))): |
| 435 | 403 |
method, path, kwargs = args[0], args[1], args[-1] |
| 436 |
args = args[:-1] |
|
| 437 |
if not (isinstance(method, str) and method and isinstance( |
|
| 438 |
path, str) and path): |
|
| 404 |
FakeResp.status_code = kwargs.get('success', 200)
|
|
| 405 |
if not (method and ( |
|
| 406 |
isinstance(method, str) or isinstance( |
|
| 407 |
method, unicode)) and ( |
|
| 408 |
isinstance(path, str) or isinstance(path, unicode))): |
|
| 439 | 409 |
self.assertRaises( |
| 440 |
AssertionError, |
|
| 441 |
self.client.request, |
|
| 442 |
*args, **kwargs) |
|
| 443 |
else: |
|
| 444 |
atoken = 'a70k3n_%s' % randint(1, 30) |
|
| 445 |
self.client.token = atoken |
|
| 446 |
if 'success' in kwargs: |
|
| 447 |
self.assertRaises( |
|
| 448 |
self.CE, |
|
| 449 |
self.client.request, |
|
| 450 |
*args, **kwargs) |
|
| 451 |
FR.status_code = kwargs['success'] |
|
| 452 |
else: |
|
| 453 |
FR.status_code = 200 |
|
| 454 |
self.client.request(*args, **kwargs) |
|
| 455 |
data = kwargs.get( |
|
| 456 |
'data', |
|
| 457 |
'{"k2": "v2", "k1": "v1"}' if 'json' in kwargs else None)
|
|
| 458 |
self.assertEqual(self.client.http_client.url, self.base_url) |
|
| 459 |
self.assertEqual(self.client.http_client.path, path) |
|
| 460 |
self.assertEqual( |
|
| 461 |
PR.mock_calls[-1], |
|
| 462 |
call(method, data, *args[2:])) |
|
| 463 |
self.assertEqual(self.client.http_client.headers, dict()) |
|
| 464 |
self.assertEqual(self.client.http_client.params, dict()) |
|
| 410 |
AssertionError, self.client.request, method, path, |
|
| 411 |
**kwargs) |
|
| 412 |
continue |
|
| 413 |
self.client.request(method, path, **kwargs) |
|
| 414 |
self.assertEqual( |
|
| 415 |
RespInit.mock_calls[-1], call(FR, connection_retry_limit=0)) |
|
| 465 | 416 |
|
| 466 | 417 |
@patch('kamaki.clients.Client.request', return_value='lala')
|
| 467 | 418 |
def _test_foo(self, foo, request): |
Also available in: Unified diff