def test_bytes_to_readable(self):
# Lower amount of blocks
blocks = 0
expected = '0.00B'
result = diskspace.bytes_to_readable(blocks)
self.assertEqual(expected, result)
# High amount of blocks
blocks = 10000000000
expected = '4.66Tb'
result = diskspace.bytes_to_readable(blocks)
self.assertEqual(expected, result)
# Amount of blocks over Tb
blocks = 100000000000000000
expected = '46566128.73Tb'
result = diskspace.bytes_to_readable(blocks)
self.assertEqual(expected, result)
# Amount of blocks negative
blocks = -1
expected = '0.00B'
result = diskspace.bytes_to_readable(blocks)
self.assertEqual(expected, result)
def test_bytes_to_readable(self):
blocksB = 1
blocksKb = 256
blocksMb = 524288
blocksGb = 1073741824
self.assertEqual(diskspace.bytes_to_readable(blocksB), '512.00B')
self.assertEqual(diskspace.bytes_to_readable(blocksKb), '128.00Kb')
self.assertEqual(diskspace.bytes_to_readable(blocksMb), '256.00Mb')
self.assertEqual(diskspace.bytes_to_readable(blocksGb), '512.00Gb')
def test_bytes_to_readable(self):
blocks = 12
output = bytes_to_readable(blocks)
self.assertEqual(str, type(output))
self.assertEqual('6.00Kb', output)
blocks = 24
output = bytes_to_readable(blocks)
self.assertEqual(str, type(output))
self.assertEqual('12.00Kb', output)
def test_blocks_label_TB(self):
"""
test if returned label is equal to value passed
"""
blocks = 1000 * 1000 * 1000 * 1000
bytes_size = diskspace.bytes_to_readable(blocks)
self.assertEqual('Tb', bytes_size[-2:])
def test_blocks_type(self):
"""
test return type
"""
blocks = 0
bytes_size = diskspace.bytes_to_readable(blocks)
self.assertIsInstance(bytes_size, str)
def test_blocks_empty(self):
"""
test if a 0 sized block chunk returns the apropriate value
"""
blocks = 0
bytes_size = diskspace.bytes_to_readable(blocks)
self.assertEqual('0.00B', bytes_size)
def test_blocks_has_something(self):
"""
test if a random block chunk returns something
"""
Anumber = random.randint(1, 6)
blocks = Anumber
bytes_size = diskspace.bytes_to_readable(blocks)
self.assertNotEqual('0.00B', bytes_size)
def test_bytes_to_readable(self):
result = ['512.00','128.00','256.00','512.00']
blocks = [1,256,524288,1073741824]
datatype = ['B','Kb','Mb','Gb']
counter = 0
for block in blocks:
result[counter] = result[counter]+(datatype[counter])
self.assertEqual(bytes_to_readable(block),result[counter])
counter= counter +1
def test_bytes_to_readable(self):
bytes = bytes_to_readable(2)
self.assertEqual(bytes, '1.00Kb')
self.assertIsNotNone(bytes)
def test_bytes_to_readable(self):
blocks = 100
self.assertEqual(bytes_to_readable(blocks), "50.00Kb")
def test_bytes_to_readable_wrong(self):
blocks = 100
self.assertNotEqual(bytes_to_readable(blocks), "50.00Mb")
def bytes_to_readable_test(self):
blocks = 224
result = "112.00Kb"
self.assertEqual(bytes_to_readable(blocks), result)
def test_bytes_to_readable_zero(self):
result = diskspace.bytes_to_readable(15986472)
self.assertEqual(result, '7.62Gb')
def test_tbytes_to_readable(self):
blocks = 2*1024*1024*1024
self.assertEqual(diskspace.bytes_to_readable(blocks), '1.00Tb')
def test_bytes_to_readable(self):
blocks = 100
result = "50.00Kb"
self.assertEqual(bytes_to_readable(blocks), result)
def test_bytes_to_readable(self):
blocks = 40
self.assertEqual(diskspace.bytes_to_readable(blocks), '20.00Kb')
def test_gbytes_to_readable(self):
blocks = 1073741824
self.assertEqual(diskspace.bytes_to_readable(blocks), '512.00Gb')
def test_bytes_to_readable(self):
result = diskspace.bytes_to_readable(0)
self.assertEqual(result, '0.00B')
def test_bytes_to_readable_with_zero(self):
blocks = 0
number_of_bytes = diskspace.bytes_to_readable(blocks)
self.assertEqual(number_of_bytes, '0.00B')
def test_bytes_to_readable_wrong(self):
blocks = 0
self.assertNotEqual(diskspace.bytes_to_readable(blocks), "100.0Kb")
def test_bytes_to_readable_tb(self):
blocks = 2871947673
number_of_bytes = diskspace.bytes_to_readable(blocks)
self.assertEqual(number_of_bytes, '1.34Tb')
def test_bytes_to_readable_gb(self):
blocks = 2097152
number_of_bytes = diskspace.bytes_to_readable(blocks)
self.assertEqual(number_of_bytes, '1.00Gb')
def test_bytes_to_readable_mb(self):
blocks = 1000000
number_of_bytes = diskspace.bytes_to_readable(blocks)
self.assertEqual(number_of_bytes, '488.28Mb')
def test_bytes_to_readable_with_one(self):
blocks = 1
number_of_bytes = diskspace.bytes_to_readable(blocks)
self.assertEqual(number_of_bytes, '512.00B')
def test_bytes_to_readble(self):
blocks = 1024
amount = diskspace.bytes_to_readable(blocks)
self.assertEqual('512.00Kb', amount)
def test_kbytes_to_readable(self):
blocks = 2
self.assertEqual(diskspace.bytes_to_readable(blocks), '1.00Kb')
def test_bytes_to_readable(self):
self.assertEquals('1.00Kb', bytes_to_readable(2))
def test_mbytes_to_readable(self):
blocks = 1048576
self.assertEqual(diskspace.bytes_to_readable(blocks), '512.00Mb')
def test_print_tree(self):
depth = -1
order = True
abs_directory = os.path.abspath('.')
cmd = 'du '
if depth != -1:
cmd += '-d {} '.format(depth)
cmd += abs_directory
raw_output = subprocess_check_output(cmd)
total_size = -1
line_regex = r'(\d+)\s+([^\s]*|\D*)'
file_tree = {}
for line in re.findall(line_regex, raw_output.strip(), re.MULTILINE):
file_path = line[-1]
dir_path = os.path.dirname(file_path)
file_size = int(line[0])
if file_path == abs_directory:
total_size = file_size
if file_path in file_tree:
file_tree[file_path]['size'] = file_size
else:
file_tree[file_path] = {
'children': [],
'size': file_size,
}
continue
if file_path not in file_tree:
file_tree[file_path] = {
'children': [],
'size': file_size,
}
if dir_path not in file_tree:
file_tree[dir_path] = {
'children': [],
'size': 0,
}
file_tree[dir_path]['children'].append(file_path)
file_tree[file_path]['size'] = file_size
largest_size = 0
for file_path in file_tree:
file_tree_entry = file_tree[file_path]
file_tree_entry['children'] = sorted(
file_tree_entry['children'],
key=lambda v: file_tree[v]['size'],
reverse=order)
file_tree_entry['print_size'] = bytes_to_readable(
file_tree_entry['size'])
largest_size = max(largest_size,
len(file_tree_entry['print_size']))
self.assertNotIsInstance(
print_tree(file_tree, file_tree[abs_directory], abs_directory,
largest_size, total_size), str)
def test_zero_bytes_to_readable(self):
blocks = 0
self.assertEqual(diskspace.bytes_to_readable(blocks), '0.00B')
