Revision 23963422 kamaki/cli/utils/test.py
| b/kamaki/cli/utils/test.py | ||
|---|---|---|
| 32 | 32 |
# or implied, of GRNET S.A. |
| 33 | 33 |
|
| 34 | 34 |
from unittest import TestCase |
| 35 |
#from tempfile import NamedTemporaryFile
|
|
| 35 |
from tempfile import NamedTemporaryFile |
|
| 36 | 36 |
from mock import patch, call |
| 37 | 37 |
from itertools import product |
| 38 | 38 |
|
| ... | ... | |
| 286 | 286 |
call(i + 1, page_size, len(items))) |
| 287 | 287 |
ph_counter += 1 |
| 288 | 288 |
|
| 289 |
def test_format_size(self): |
|
| 290 |
from kamaki.cli.utils import format_size |
|
| 291 |
from kamaki.cli import CLIError |
|
| 292 |
for v in ('wrong', {1: '1', 2: '2'}, ('tuples', 'not OK'), [1, 2]):
|
|
| 293 |
self.assertRaises(CLIError, format_size, v) |
|
| 294 |
for step, B, K, M, G, T in ( |
|
| 295 |
(1000, 'B', 'KB', 'MB', 'GB', 'TB'), |
|
| 296 |
(1024, 'B', 'KiB', 'MiB', 'GiB', 'TiB')): |
|
| 297 |
Ki, Mi, Gi = step, step * step, step * step * step |
|
| 298 |
for before, after in ( |
|
| 299 |
(0, '0' + B), (512, '512' + B), ( |
|
| 300 |
Ki - 1, '%s%s' % (step - 1, B)), |
|
| 301 |
(Ki, '1' + K), (42 * Ki, '42' + K), ( |
|
| 302 |
Mi - 1, '%s.99%s' % (step - 1, K)), |
|
| 303 |
(Mi, '1' + M), (42 * Mi, '42' + M), ( |
|
| 304 |
Ki * Mi - 1, '%s.99%s' % (step - 1, M)), |
|
| 305 |
(Gi, '1' + G), (42 * Gi, '42' + G), ( |
|
| 306 |
Mi * Mi - 1, '%s.99%s' % (step - 1, G)), |
|
| 307 |
(Mi * Mi, '1' + T), (42 * Mi * Mi, '42' + T), ( |
|
| 308 |
Mi * Gi - 1, '%s.99%s' % (step - 1, T)), ( |
|
| 309 |
42 * Mi * Gi, '%s%s' % (42 * Ki, T))): |
|
| 310 |
self.assertEqual(format_size(before, step == 1000), after) |
|
| 311 |
|
|
| 312 |
def test_to_bytes(self): |
|
| 313 |
from kamaki.cli.utils import to_bytes |
|
| 314 |
for v in ('wrong', 'KABUM', 'kbps', 'kibps'):
|
|
| 315 |
self.assertRaises(ValueError, to_bytes, v, 'B') |
|
| 316 |
self.assertRaises(ValueError, to_bytes, 42, v) |
|
| 317 |
for v in ([1, 2, 3], ('kb', 'mb'), {'kb': 1, 'byte': 2}):
|
|
| 318 |
self.assertRaises(TypeError, to_bytes, v, 'B') |
|
| 319 |
self.assertRaises(AttributeError, to_bytes, 42, v) |
|
| 320 |
kl, ki = 1000, 1024 |
|
| 321 |
for size, (unit, factor) in product( |
|
| 322 |
(0, 42, 3.14, 1023, 10000), |
|
| 323 |
( |
|
| 324 |
('B', 1), ('b', 1),
|
|
| 325 |
('KB', kl), ('KiB', ki),
|
|
| 326 |
('mb', kl * kl), ('mIb', ki * ki),
|
|
| 327 |
('gB', kl * kl * kl), ('GIB', ki * ki * ki),
|
|
| 328 |
('TB', kl * kl * kl * kl), ('tiB', ki * ki * ki * ki))):
|
|
| 329 |
self.assertEqual(to_bytes(size, unit), int(size * factor)) |
|
| 330 |
|
|
| 331 |
def test_dict2file(self): |
|
| 332 |
from kamaki.cli.utils import dict2file, INDENT_TAB |
|
| 333 |
for d, depth in product(( |
|
| 334 |
{'k': 42},
|
|
| 335 |
{'k1': 'v1', 'k2': [1, 2, 3], 'k3': {'k': 'v'}},
|
|
| 336 |
{'k1': {
|
|
| 337 |
'k1.1': 'v1.1', |
|
| 338 |
'k1.2': [1, 2, 3], |
|
| 339 |
'k1.3': {'k': 'v'}}}),
|
|
| 340 |
(-42, 0, 42)): |
|
| 341 |
exp = '' |
|
| 342 |
exp_d = [] |
|
| 343 |
exp_l = [] |
|
| 344 |
exp, exp_d, exp_l = '', [], [] |
|
| 345 |
with NamedTemporaryFile() as f: |
|
| 346 |
for k, v in d.items(): |
|
| 347 |
sfx = '\n' |
|
| 348 |
if isinstance(v, dict): |
|
| 349 |
exp_d.append(call(v, f, depth + 1)) |
|
| 350 |
elif isinstance(v, tuple) or isinstance(v, list): |
|
| 351 |
exp_l.append(call(v, f, depth + 1)) |
|
| 352 |
else: |
|
| 353 |
sfx = '%s\n' % v |
|
| 354 |
exp += '%s%s: %s' % ( |
|
| 355 |
' ' * (depth * INDENT_TAB), k, sfx) |
|
| 356 |
with patch('kamaki.cli.utils.dict2file') as D2F:
|
|
| 357 |
with patch('kamaki.cli.utils.list2file') as L2F:
|
|
| 358 |
dict2file(d, f, depth) |
|
| 359 |
f.seek(0) |
|
| 360 |
self.assertEqual(f.read(), exp) |
|
| 361 |
self.assertEqual(L2F.mock_calls, exp_l) |
|
| 362 |
self.assertEqual(D2F.mock_calls, exp_d) |
|
| 363 |
|
|
| 364 |
def test_list2file(self): |
|
| 365 |
from kamaki.cli.utils import list2file, INDENT_TAB |
|
| 366 |
for l, depth in product( |
|
| 367 |
( |
|
| 368 |
(1, 2, 3), |
|
| 369 |
[1, 2, 3], |
|
| 370 |
('v', [1, 2, 3], (1, 2, 3), {'1': 1, 2: '2', 3: 3}),
|
|
| 371 |
['v', {'k1': 'v1', 'k2': [1, 2, 3], 'k3': {1: '1'}}]),
|
|
| 372 |
(-42, 0, 42)): |
|
| 373 |
with NamedTemporaryFile() as f: |
|
| 374 |
exp, exp_d, exp_l = '', [], [] |
|
| 375 |
for v in l: |
|
| 376 |
if isinstance(v, dict): |
|
| 377 |
exp_d.append(call(v, f, depth + 1)) |
|
| 378 |
elif isinstance(v, list) or isinstance(v, tuple): |
|
| 379 |
exp_l.append(call(v, f, depth + 1)) |
|
| 380 |
else: |
|
| 381 |
exp += '%s%s\n' % (' ' * INDENT_TAB * depth, v)
|
|
| 382 |
with patch('kamaki.cli.utils.dict2file') as D2F:
|
|
| 383 |
with patch('kamaki.cli.utils.list2file') as L2F:
|
|
| 384 |
list2file(l, f, depth) |
|
| 385 |
f.seek(0) |
|
| 386 |
self.assertEqual(f.read(), exp) |
|
| 387 |
self.assertEqual(L2F.mock_calls, exp_l) |
|
| 388 |
self.assertEqual(D2F.mock_calls, exp_d) |
|
| 389 |
|
|
| 390 |
def test__parse_with_regex(self): |
|
| 391 |
from re import compile as r_compile |
|
| 392 |
from kamaki.cli.utils import _parse_with_regex |
|
| 393 |
for args in product( |
|
| 394 |
( |
|
| 395 |
'this is a line', |
|
| 396 |
'this_is_also_a_line', |
|
| 397 |
'This "text" is quoted', |
|
| 398 |
'This "quoted" "text" is more "complicated"', |
|
| 399 |
'Is this \'quoted\' text "double \'quoted\' or not?"', |
|
| 400 |
'"What \'about\' the" oposite?', |
|
| 401 |
' Try with a " single double quote', |
|
| 402 |
'Go "down \'deep " deeper \'bottom \' up" go\' up" !'), |
|
| 403 |
( |
|
| 404 |
'\'.*?\'|".*?"|^[\S]*$', |
|
| 405 |
r'"([A-Za-z0-9_\./\\-]*)"', |
|
| 406 |
r'\"(.+?)\"', |
|
| 407 |
'\\^a\\.\\*\\$')): |
|
| 408 |
r_parser = r_compile(args[1]) |
|
| 409 |
self.assertEqual( |
|
| 410 |
_parse_with_regex(*args), |
|
| 411 |
(r_parser.split(args[0]), r_parser.findall(args[0]))) |
|
| 412 |
|
|
| 413 |
def test_split_input(self): |
|
| 414 |
from kamaki.cli.utils import split_input |
|
| 415 |
for line, expected in ( |
|
| 416 |
('unparsable', ['unparsable']),
|
|
| 417 |
('"parsable"', ['parsable']),
|
|
| 418 |
('"parse" out', ['parse', 'out']),
|
|
| 419 |
('"one', ['"one']),
|
|
| 420 |
('two" or" more"', ['two', ' or', 'more"']),
|
|
| 421 |
('Go "down \'deep " deeper \'bottom \' up" go\' up" !', [
|
|
| 422 |
'Go', "down 'deep ", 'deeper', 'bottom ', |
|
| 423 |
'up', " go' up", '!']), |
|
| 424 |
('Is "this" a \'parsed\' string?', [
|
|
| 425 |
'Is', 'this', 'a', 'parsed', 'string?'])): |
|
| 426 |
self.assertEqual(split_input(line), expected) |
|
| 427 |
|
|
| 428 |
@patch('kamaki.cli.utils._readline', return_value='read line')
|
|
| 429 |
@patch('kamaki.cli.utils._flush')
|
|
| 430 |
@patch('kamaki.cli.utils._write')
|
|
| 431 |
def test_ask_user(self, WR, FL, RL): |
|
| 432 |
from kamaki.cli.utils import ask_user |
|
| 433 |
msg = 'some question' |
|
| 434 |
self.assertFalse(ask_user(msg)) |
|
| 435 |
WR.assert_called_once_with('%s [y/N]: ' % msg)
|
|
| 436 |
FL.assert_called_once_with() |
|
| 437 |
RL.assert_called_once_with() |
|
| 438 |
|
|
| 439 |
self.assertTrue(ask_user(msg, ('r', )))
|
|
| 440 |
self.assertEqual(WR.mock_calls[-1], call('%s [r/N]: ' % msg))
|
|
| 441 |
self.assertEqual(FL.mock_calls, 2 * [call()]) |
|
| 442 |
self.assertEqual(RL.mock_calls, 2 * [call()]) |
|
| 443 |
|
|
| 444 |
self.assertTrue(ask_user(msg, ('Z', 'r', 'k')))
|
|
| 445 |
self.assertEqual(WR.mock_calls[-1], call('%s [Z, r, k/N]: ' % msg))
|
|
| 446 |
self.assertEqual(FL.mock_calls, 3 * [call()]) |
|
| 447 |
self.assertEqual(RL.mock_calls, 3 * [call()]) |
|
| 448 |
|
|
| 449 |
@patch('kamaki.cli.utils._flush')
|
|
| 450 |
@patch('kamaki.cli.utils._write')
|
|
| 451 |
def test_spiner(self, WR, FL): |
|
| 452 |
from kamaki.cli.utils import spiner |
|
| 453 |
spins = ('/', '-', '\\', '|')
|
|
| 454 |
prev = 1 |
|
| 455 |
for i, SP in enumerate(spiner(6)): |
|
| 456 |
if not i: |
|
| 457 |
self.assertEqual(WR.mock_calls[-2], call(' '))
|
|
| 458 |
elif i > 5: |
|
| 459 |
break |
|
| 460 |
self.assertEqual(SP, None) |
|
| 461 |
self.assertEqual(WR.mock_calls[-1], call('\b%s' % spins[i % 4]))
|
|
| 462 |
self.assertEqual(FL.mock_calls, prev * [call()]) |
|
| 463 |
prev += 1 |
|
| 464 |
|
|
| 465 |
def test_remove_from_items(self): |
|
| 466 |
from kamaki.cli.utils import remove_from_items |
|
| 467 |
for v in ('wrong', [1, 2, 3], [{}, 2, {}]):
|
|
| 468 |
self.assertRaises(AssertionError, remove_from_items, v, 'none') |
|
| 469 |
d = dict(k1=1, k2=dict(k2=2, k3=3), k3=3, k4=4) |
|
| 470 |
for k in (d.keys() + ['kN']): |
|
| 471 |
tmp1, tmp2 = dict(d), dict(d) |
|
| 472 |
remove_from_items([tmp1, ], k) |
|
| 473 |
tmp1.pop(k, None) |
|
| 474 |
self.assert_dicts_are_equal(tmp1, tmp2) |
|
| 475 |
for k in (d.keys() + ['kN']): |
|
| 476 |
tmp1, tmp2 = dict(d), dict(d) |
|
| 477 |
remove_from_items([tmp1, tmp2], k) |
|
| 478 |
self.assert_dicts_are_equal(tmp1, tmp2) |
|
| 479 |
|
|
| 289 | 480 |
|
| 290 | 481 |
if __name__ == '__main__': |
| 291 | 482 |
from sys import argv |
Also available in: Unified diff