def test_cleanup_items_removes_and_yields_items_as_necessary( self, monkeypatch, tmp_folder): """Test ``cleanup_items()`` if it successfully removes every item. :param monkeypatch: pytest monkey patch fixture :type monkeypatch: _pytest.monkeypatch.MonkeyPatch :param tmp_folder: Test params and dummy test folder factory fixture pair. :type tmp_folder: (dict, dirtools.tests.factory.DummyFolderFactory) """ params, _factory = tmp_folder if params['total_items'] == 0: return # Use another factory folder that is not shared with other tests with DummyFolderFactory(params['total_items'], params['total_size'], level=params['level']) as factory: scan = Folder(factory.path, params['sort_by'], level=params['level']) _humanise_item = Mock(side_effect=scan._humanise_item) monkeypatch.setattr(scan, '_humanise_item', _humanise_item) # cleanup must return a generator even the same (or greater) total size given result = scan.cleanup_items( bytes2human(scan.total_size, precision=11)) assert isinstance(result, types.GeneratorType) with pytest.raises(StopIteration): next(result) _humanise_item.assert_not_called() # Get a copy of items and remove one by one items = tuple(scan.items(humanise=False)) _humanise_item.assert_not_called() for item in items: last_total = scan.total_size last_items_len = scan._items_len mines_one_byte = bytes2human(scan.total_size - 1, precision=11) full_path = os.path.abspath( os.path.join(factory.path, item['name'])) assert os.path.exists(full_path) # attempt to remove single item deleted = next( scan.cleanup_items(mines_one_byte, humanise=False)) _humanise_item.assert_not_called() assert deleted == item assert scan.total_size == (last_total - deleted['size']) assert scan._items_len == last_items_len - 1 assert not os.path.exists(full_path)
def test_public_methods_should_block_before_processing( self, monkeypatch, tmp_folder): """Make sure public methods and properties blocks until scanning finishes. :param monkeypatch: pytest monkey patch fixture :type monkeypatch: _pytest.monkeypatch.MonkeyPatch :param tmp_folder: Test params and dummy test folder factory fixture pair. :type tmp_folder: (dict, dirtools.tests.factory.DummyFolderFactory) """ params, factory = tmp_folder # Mock the _await internal function first scan = Folder(factory.path, params['sort_by'], params['level']) _ = scan.items() blocker = Mock() monkeypatch.setattr(scan, '_await', blocker) # len(scan) assert len(scan) == factory.total_items blocker.assert_called_once() blocker.reset_mock() # .total_size assert scan.total_size == factory.total_size blocker.assert_called_once() blocker.reset_mock() # .items _ = scan.items() blocker.assert_called_once() blocker.reset_mock() # .cleanup_items() calls human2bytes once _human2bytes = Mock(side_effect=human2bytes) monkeypatch.setattr('dirtools.utils.human2bytes', _human2bytes) factory_size_human = bytes2human(factory.total_size, precision=11) with pytest.raises(StopIteration): next(scan.cleanup_items(factory_size_human)) _human2bytes.assert_called_once_with(factory_size_human) blocker.assert_called_once() blocker.reset_mock() # So give -1 to make it block actually, run only for >0 sizes if factory.total_size > 0: sh_rmtree = Mock() os_remove = Mock() monkeypatch.setattr('shutil.rmtree', sh_rmtree) monkeypatch.setattr(os, 'remove', os_remove) # Attempt to remove single item next( scan.cleanup_items( bytes2human(factory.total_size - 1, precision=11))) blocker.assert_called_once() blocker.reset_mock() assert sh_rmtree.called or os_remove.called # .resort() called at the end of async loop, so it shouldn't _await scan.resort(params['sort_by']) blocker.assert_not_called() blocker.reset_mock()
def invoke_dirtools3(args): """Command line interface to the dirtools package.""" # Get SortBy enum val try: sortby = next(s for s in SortBy if args.sortby.upper() == str(s)) except StopIteration: sys.stderr.write("Invalid sort by option: {0}".format(sortby)) return path = args.path precision = args.precision depth = args.depth nohuman = args.nohuman trim_down = args.trim_down output = args.output # Create folder object and start its scanning process scan = Folder(path, sortby, level=depth) old_size = scan.total_size old_items_len = len(scan) # Only folder scanning and listing etc if trim_down is None: items = scan.items(humanise=not nohuman, precision=precision) # Do not allow to pass only digit value because it will be interpreted as # byte value and probably this was an accident. elif trim_down.isdigit(): sys.stderr.write( "--trim-down value cannot be only numeric to prevent accident, {0} given.".format( trim_down ) ) return # Folder trimming else: items = scan.cleanup_items(trim_down, humanise=not nohuman, precision=precision) # CSV - custom if output.lower() == "csv": with io.StringIO() as csv_io: writer = csv.writer(csv_io, quoting=csv.QUOTE_NONNUMERIC) writer.writerow(TABLE_HEADERS.values()) writer.writerows(i.values() for i in items) rows = csv_io.getvalue().rstrip() # Display it with tabulate else: rows = tabulate(items, TABLE_HEADERS, tablefmt=output, stralign="right") sys.stdout.write(rows) # Give summary info regarding to its listing lit = lambda n, sing, plur: str(n) + (f" {sing}" if n == 1 else f" {plur}") if trim_down is None: sys.stdout.write( "\n{ct} with total of {size} data; took {exec}.".format( exec=lit(scan.exec_took, "second", "seconds"), size=bytes2human(scan.total_size, precision=precision), ct=lit(len(scan), "item", "items"), ) ) # or cleaning operation else: del_len = len(scan) - old_items_len del_size = bytes2human(old_size - scan.total_size, precision=precision) sys.stderr.write( "{del_len:d} items with total of {del_size} data has been deleted.".format( del_len=del_len, del_size=del_size ) ) sys.stderr.write( "Currently {len} items left with {size} of data; took {exec} second(s).".format( len=len(scan), size=bytes2human(scan.total_size, precision=precision), exec=scan.exec_took, ) )