From 641a9a6569ab6413c13ec83a34f6305b747955f3 Mon Sep 17 00:00:00 2001 From: Andrew Ferrier <107015+andrewferrier@users.noreply.github.com> Date: Fri, 30 Aug 2024 18:45:36 +0100 Subject: [PATCH] style: Add pre-commit ruff and meta hooks, format --- .pre-commit-config.yaml | 9 + normfn | 42 +- tests/BaseTestClasses.py | 65 +- tests/Direct/test_Direct_Arguments.py | 6 +- tests/Direct/test_Direct_Basic.py | 713 ++++++++++++------ tests/Direct/test_Direct_Errors.py | 24 +- tests/Direct/test_Direct_FrozenTime.py | 126 ++-- tests/Subprocess/test_Subprocess_Arguments.py | 108 ++- tests/Subprocess/test_Subprocess_Basic.py | 411 ++++++---- 9 files changed, 1021 insertions(+), 483 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b6bb388..8e47bb5 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,6 +1,10 @@ # See https://pre-commit.com for more information --- repos: + - repo: meta + hooks: + - id: check-hooks-apply + - id: check-useless-excludes - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.6.0 hooks: @@ -20,3 +24,8 @@ repos: rev: v3.17.0 hooks: - id: pyupgrade + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.6.3 + hooks: + - id: ruff + - id: ruff-format diff --git a/normfn b/normfn index dcb2a41..16264f2 100755 --- a/normfn +++ b/normfn @@ -57,8 +57,7 @@ def main(argv, syserr_handler): "--verbose", action="count", default=0, - help="Add debugging output. " - "Using this twice makes it doubly verbose.", + help="Add debugging output. " "Using this twice makes it doubly verbose.", ) _ = parser.add_argument( @@ -201,9 +200,7 @@ def main(argv, syserr_handler): "This is the default.", ) - parser.set_defaults( - time_option="earliest", undo_log_file=get_default_log_file() - ) + parser.set_defaults(time_option="earliest", undo_log_file=get_default_log_file()) class FilenamesAction(argparse.Action): # pylint: disable=too-few-public-methods @@ -376,11 +373,7 @@ def datetime_prefix(args, non_extension: str, filename: str): if matchobj.group("prefix") != "" else "" ) - + ( - matchobj.group("suffix") - if matchobj.group("suffix") != "" - else "" - ) + + (matchobj.group("suffix") if matchobj.group("suffix") != "" else "") ) logger.debug("replacement() returned: " + replaceValue) @@ -407,7 +400,9 @@ def datetime_prefix(args, non_extension: str, filename: str): DATE_TIME_SEPARATOR = r"([-_T\s]|\sat\s|,\s)" REGEX = ( - r"^(?P.*?)[-_]?" + r"(" + + r"^(?P.*?)[-_]?" + + r"(" + + # Y-M-D style r"(?P" + YEAR @@ -473,13 +468,10 @@ def datetime_prefix(args, non_extension: str, filename: str): if args.add_time: newname = ( - timetouse.strftime("%Y-%m-%dT%H-%M-%S") - + newname_with_dash_if_needed + timetouse.strftime("%Y-%m-%dT%H-%M-%S") + newname_with_dash_if_needed ) else: - newname = ( - timetouse.strftime("%Y-%m-%d") + newname_with_dash_if_needed - ) + newname = timetouse.strftime("%Y-%m-%d") + newname_with_dash_if_needed return newname @@ -493,9 +485,7 @@ def process_filename(filename: str, args): if not args.all: (exclude, why) = should_exclude(filename, basename) if exclude: - logger.info( - f"Skipping {filename.strip()} as it matches pattern {why}" - ) + logger.info(f"Skipping {filename.strip()} as it matches pattern {why}") return filename (non_extension, extension) = os.path.splitext(basename) @@ -506,9 +496,7 @@ def process_filename(filename: str, args): original_filename = filename filename = os.path.join(os.path.dirname(original_filename), newname) - logger.debug( - f"Potential new filename for {original_filename} is {filename}" - ) + logger.debug(f"Potential new filename for {original_filename} is {filename}") if filename == original_filename: logger.debug("New filename would be identical, skipping.") @@ -586,7 +574,7 @@ def validate_move(args, original_filename: str, filename: str) -> None: ) -def rlinput(prompt: str, prefill: str=""): +def rlinput(prompt: str, prefill: str = ""): if os.name == "nt": return input(prompt) else: @@ -629,9 +617,7 @@ def shiftfile(args, source: str, target: str): def check_undo_log_file_header(args): if not os.path.exists(args.undo_log_file): with open(args.undo_log_file, "w") as log_file: - wrapper = textwrap.TextWrapper( - initial_indent="# ", subsequent_indent="# " - ) + wrapper = textwrap.TextWrapper(initial_indent="# ", subsequent_indent="# ") log_file.write("#!/bin/sh\n") log_file.write( wrapper.fill( @@ -700,9 +686,7 @@ def readchar(): def insensitiveize(string: str) -> str: - return "".join( - map(lambda char: ("[" + char.lower() + char.upper() + "]"), string) - ) + return "".join(map(lambda char: ("[" + char.lower() + char.upper() + "]"), string)) class FatalException(Exception): diff --git a/tests/BaseTestClasses.py b/tests/BaseTestClasses.py index dac9f59..87aafaf 100644 --- a/tests/BaseTestClasses.py +++ b/tests/BaseTestClasses.py @@ -16,33 +16,48 @@ class NormalizeFilenameTestCase(unittest.TestCase): - COMMAND = os.path.normpath(os.path.join(os.getcwd(), 'normfn')) + COMMAND = os.path.normpath(os.path.join(os.getcwd(), "normfn")) def setUp(self): self.workingDir = tempfile.mkdtemp() def getDatePrefix(self, postfixDash=True): - if (postfixDash is True): + if postfixDash is True: return datetime.now().strftime("%Y-%m-%d-") else: return datetime.now().strftime("%Y-%m-%d") def directoryFileCount(self, directory): - return len([item for item in os.listdir(directory) if os.path.isfile(os.path.join(directory, item))]) + return len( + [ + item + for item in os.listdir(directory) + if os.path.isfile(os.path.join(directory, item)) + ] + ) def directoryDirCount(self, directory): - return len([item for item in os.listdir(directory) if os.path.isdir(os.path.join(directory, item))]) + return len( + [ + item + for item in os.listdir(directory) + if os.path.isdir(os.path.join(directory, item)) + ] + ) def getOriginalScriptPath(self): module_path = inspect.getfile(inspect.currentframe()) - module_path = os.path.join(os.path.dirname(os.path.dirname(module_path)), 'normfn') + module_path = os.path.join( + os.path.dirname(os.path.dirname(module_path)), "normfn" + ) return module_path def invokeDirectly(self, inputFiles, extraParams=[]): import importlib.machinery + module_path = self.getOriginalScriptPath() - loader = importlib.machinery.SourceFileLoader('normfn', module_path) + loader = importlib.machinery.SourceFileLoader("normfn", module_path) spec = spec_from_loader(os.path.basename(module_path), loader) normalize_filename = module_from_spec(spec) spec.loader.exec_module(normalize_filename) @@ -51,11 +66,11 @@ def invokeDirectly(self, inputFiles, extraParams=[]): options.extend(inputFiles) options.extend(extraParams) - options.extend(['--no-undo-log-file']) + options.extend(["--no-undo-log-file"]) stream = io.StringIO() handler = logging.StreamHandler(stream) - log = logging.getLogger('normfn') + log = logging.getLogger("normfn") log.propagate = False log.setLevel(logging.DEBUG) log.addHandler(handler) @@ -70,7 +85,15 @@ def invokeDirectly(self, inputFiles, extraParams=[]): return error - def invokeAsSubprocess(self, inputFiles, extraParams=[], feedInput=None, cwd=None, expectOutput=False, useUndoFile=False): + def invokeAsSubprocess( + self, + inputFiles, + extraParams=[], + feedInput=None, + cwd=None, + expectOutput=False, + useUndoFile=False, + ): if cwd is None: cwd = self.workingDir @@ -78,13 +101,13 @@ def invokeAsSubprocess(self, inputFiles, extraParams=[], feedInput=None, cwd=Non undo_log_file.close() if os.name == "nt": - options = ['python', NormalizeFilenameTestCase.COMMAND] + options = ["python", NormalizeFilenameTestCase.COMMAND] else: options = [NormalizeFilenameTestCase.COMMAND] options.extend(inputFiles) options.extend(extraParams) - options.extend(['--undo-log-file=' + undo_log_file.name]) + options.extend(["--undo-log-file=" + undo_log_file.name]) if feedInput: p = Popen(options, stdin=PIPE, stdout=PIPE, stderr=PIPE, cwd=cwd) @@ -122,13 +145,19 @@ def executeUndoCommands(self, commands): return maxReturnCode @contextmanager - def invokeAsPexpect(self, inputFiles, extraParams=[], expectedExitStatus=None, expectedOutputRegex=None): + def invokeAsPexpect( + self, + inputFiles, + extraParams=[], + expectedExitStatus=None, + expectedOutputRegex=None, + ): options = [NormalizeFilenameTestCase.COMMAND] options.extend(inputFiles) options.extend(extraParams) - options.extend(['--no-undo-log-file']) + options.extend(["--no-undo-log-file"]) - command = ' '.join(options) + command = " ".join(options) stream = io.BytesIO() @@ -144,18 +173,20 @@ def invokeAsPexpect(self, inputFiles, extraParams=[], expectedExitStatus=None, e self.assertEqual(expectedExitStatus, child.exitstatus) if expectedOutputRegex is not None: - self.assertRegex(str(child.logfile_read.getvalue(), 'utf-8'), expectedOutputRegex) + self.assertRegex( + str(child.logfile_read.getvalue(), "utf-8"), expectedOutputRegex + ) def touch(self, fname): os.makedirs(os.path.dirname(fname), exist_ok=True) - open(fname, 'w').close() + open(fname, "w").close() def remove_dir_write_permissions(self, fname): os.chmod(fname, S_IRUSR | S_IXUSR) def writeFile(self, fname, contents): os.makedirs(os.path.dirname(fname), exist_ok=True) - with open(fname, 'w') as filename: + with open(fname, "w") as filename: filename.write(contents) def readFile(self, fname): diff --git a/tests/Direct/test_Direct_Arguments.py b/tests/Direct/test_Direct_Arguments.py index e426a22..dbd03ab 100644 --- a/tests/Direct/test_Direct_Arguments.py +++ b/tests/Direct/test_Direct_Arguments.py @@ -8,11 +8,11 @@ def setUp(self): super().setUp() def test_targetfile_exists_with_force(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.writeFile(filename, "original") - filename2 = os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt') + filename2 = os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") self.writeFile(filename2, "new") - self.invokeDirectly([filename], extraParams=['--force']) + self.invokeDirectly([filename], extraParams=["--force"]) self.assertFalse(os.path.exists(filename)) self.assertTrue(os.path.exists(filename2)) self.assertEqual(self.readFile(filename2), "original") diff --git a/tests/Direct/test_Direct_Basic.py b/tests/Direct/test_Direct_Basic.py index bb2854c..018dbbc 100644 --- a/tests/Direct/test_Direct_Basic.py +++ b/tests/Direct/test_Direct_Basic.py @@ -9,570 +9,847 @@ def setUp(self): super().setUp() def test_basicdateprefix(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_nochangeneeded(self): - filename = os.path.join(self.workingDir, '2015-01-01-blah.txt') + filename = os.path.join(self.workingDir, "2015-01-01-blah.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_path_normalization(self): - subdirectory = os.path.join(self.workingDir, 'subdirectory') + subdirectory = os.path.join(self.workingDir, "subdirectory") os.makedirs(subdirectory, exist_ok=True) self.invokeDirectly([subdirectory + "/"]) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'subdirectory')) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "subdirectory") + ) def test_standalone_directory(self): - subdirectory = os.path.join(self.workingDir, 'subdirectory') + subdirectory = os.path.join(self.workingDir, "subdirectory") os.makedirs(subdirectory) self.invokeDirectly([subdirectory]) self.assertPathDoesntExist(subdirectory) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'subdirectory')) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "subdirectory") + ) def test_directoriesonly_nonrecursive(self): - subdirectory = os.path.join(self.workingDir, 'abc') - subsubdirectory = os.path.join(self.workingDir, 'abc', 'def') + subdirectory = os.path.join(self.workingDir, "abc") + subsubdirectory = os.path.join(self.workingDir, "abc", "def") os.makedirs(subsubdirectory, exist_ok=True) self.invokeDirectly([subdirectory]) self.assertPathDoesntExist(subdirectory) self.assertPathDoesntExist(subsubdirectory) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'abc')) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'abc', 'def')) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "abc") + ) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "abc", "def") + ) def test_directoriesonly_recursive(self): - subdirectory = os.path.join(self.workingDir, 'abc') - subsubdirectory = os.path.join(self.workingDir, 'abc', 'def') + subdirectory = os.path.join(self.workingDir, "abc") + subsubdirectory = os.path.join(self.workingDir, "abc", "def") os.makedirs(subsubdirectory, exist_ok=True) - self.invokeDirectly([subdirectory], extraParams=['--recursive']) + self.invokeDirectly([subdirectory], extraParams=["--recursive"]) self.assertPathDoesntExist(subdirectory) self.assertPathDoesntExist(subsubdirectory) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'abc')) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'abc', self.getDatePrefix() + 'def')) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "abc") + ) + self.assertPathExists( + os.path.join( + self.workingDir, + self.getDatePrefix() + "abc", + self.getDatePrefix() + "def", + ) + ) def test_directory_withfiles_norecursive(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, 'blah_2015_01_01_bling.txt') - filenameAfter = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir', 'blah_2015_01_01_bling.txt') - self.touch(filename) - filename2 = os.path.join(subWorkingDir, 'xyz-2015-03-04.txt') - filename2After = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir', 'xyz-2015-03-04.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, "blah_2015_01_01_bling.txt") + filenameAfter = os.path.join( + self.workingDir, + self.getDatePrefix() + "subWorkingDir", + "blah_2015_01_01_bling.txt", + ) + self.touch(filename) + filename2 = os.path.join(subWorkingDir, "xyz-2015-03-04.txt") + filename2After = os.path.join( + self.workingDir, + self.getDatePrefix() + "subWorkingDir", + "xyz-2015-03-04.txt", + ) self.touch(filename2) - filename3 = os.path.join(subWorkingDir, 'subWorkingDir2', 'abc-2015-03-04.txt') - filename3After = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir', 'subWorkingDir2', - 'abc-2015-03-04.txt') + filename3 = os.path.join(subWorkingDir, "subWorkingDir2", "abc-2015-03-04.txt") + filename3After = os.path.join( + self.workingDir, + self.getDatePrefix() + "subWorkingDir", + "subWorkingDir2", + "abc-2015-03-04.txt", + ) self.touch(filename3) error = self.invokeDirectly([subWorkingDir]) self.assertPathDoesntExist(os.path.join(subWorkingDir)) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir')) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + "subWorkingDir") + ) self.assertPathDoesntExist(os.path.join(filename)) self.assertPathDoesntExist(os.path.join(filename2)) self.assertPathDoesntExist(os.path.join(filename3)) self.assertPathExists(os.path.join(filenameAfter)) self.assertPathExists(os.path.join(filename2After)) self.assertPathExists(os.path.join(filename3After)) - self.assertEqual(2, self.directoryFileCount(os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir', - 'subWorkingDir2'))) - self.assertEqual('', error) + self.assertEqual( + 2, + self.directoryFileCount( + os.path.join(self.workingDir, self.getDatePrefix() + "subWorkingDir") + ), + ) + self.assertEqual( + 1, + self.directoryFileCount( + os.path.join( + self.workingDir, + self.getDatePrefix() + "subWorkingDir", + "subWorkingDir2", + ) + ), + ) + self.assertEqual("", error) def test_directory_withfiles_recursive(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, 'blah_2015_01_01_bling.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, "blah_2015_01_01_bling.txt") self.touch(filename) - filename2 = os.path.join(subWorkingDir, 'xyz-2015-03-04.txt') + filename2 = os.path.join(subWorkingDir, "xyz-2015-03-04.txt") self.touch(filename2) - filename3 = os.path.join(subWorkingDir, 'subWorkingDir2', 'abc-2015-03-04.txt') + filename3 = os.path.join(subWorkingDir, "subWorkingDir2", "abc-2015-03-04.txt") self.touch(filename3) - error = self.invokeDirectly([subWorkingDir], extraParams=['--recursive']) - newsubWorkingDir = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir') + error = self.invokeDirectly([subWorkingDir], extraParams=["--recursive"]) + newsubWorkingDir = os.path.join( + self.workingDir, self.getDatePrefix() + "subWorkingDir" + ) self.assertPathDoesntExist(filename) - self.assertPathExists(os.path.join(newsubWorkingDir, '2015-01-01-blah_bling.txt')) + self.assertPathExists( + os.path.join(newsubWorkingDir, "2015-01-01-blah_bling.txt") + ) self.assertPathDoesntExist(filename2) - self.assertPathExists(os.path.join(newsubWorkingDir, '2015-03-04-xyz.txt')) + self.assertPathExists(os.path.join(newsubWorkingDir, "2015-03-04-xyz.txt")) self.assertPathDoesntExist(filename3) - self.assertPathExists(os.path.join(newsubWorkingDir, self.getDatePrefix() + 'subWorkingDir2', '2015-03-04-abc.txt')) + self.assertPathExists( + os.path.join( + newsubWorkingDir, + self.getDatePrefix() + "subWorkingDir2", + "2015-03-04-abc.txt", + ) + ) self.assertEqual(2, self.directoryFileCount(newsubWorkingDir)) - self.assertEqual(1, self.directoryFileCount(os.path.join(newsubWorkingDir, self.getDatePrefix() + 'subWorkingDir2'))) - self.assertEqual('', error) + self.assertEqual( + 1, + self.directoryFileCount( + os.path.join(newsubWorkingDir, self.getDatePrefix() + "subWorkingDir2") + ), + ) + self.assertEqual("", error) def test_ridiculousdate1(self): - filename = os.path.join(self.workingDir, 'blah-2100-01-01.txt') + filename = os.path.join(self.workingDir, "blah-2100-01-01.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah-2100-01-01.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "blah-2100-01-01.txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_ridiculousdate2(self): - filename = os.path.join(self.workingDir, 'blah-1899-01-01.txt') + filename = os.path.join(self.workingDir, "blah-1899-01-01.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah-1899-01-01.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "blah-1899-01-01.txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_invaliddate1(self): - filename = os.path.join(self.workingDir, 'blah-1998-20-01.txt') + filename = os.path.join(self.workingDir, "blah-1998-20-01.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah-1998-20-01.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "blah-1998-20-01.txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_invaliddate2(self): - filename = os.path.join(self.workingDir, 'blah-1998-01-41.txt') + filename = os.path.join(self.workingDir, "blah-1998-01-41.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1998-01-blah-41.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1998-01-blah-41.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_invaliddate3(self): - filename = os.path.join(self.workingDir, 'blah-1998-01-35.txt') + filename = os.path.join(self.workingDir, "blah-1998-01-35.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1998-01-blah-35.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1998-01-blah-35.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_invaliddate4(self): - filename = os.path.join(self.workingDir, 'blah-1998-13-35.txt') + filename = os.path.join(self.workingDir, "blah-1998-13-35.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah-1998-13-35.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "blah-1998-13-35.txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_basic_compressed_datemove(self): - filename = os.path.join(self.workingDir, 'blah-20150101.txt') + filename = os.path.join(self.workingDir, "blah-20150101.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_basic_invalid_compressed_nodatemove(self): - filename = os.path.join(self.workingDir, 'blah-20153101.txt') + filename = os.path.join(self.workingDir, "blah-20153101.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah-20153101.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "blah-20153101.txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_basic_compressed_withspace(self): - filename = os.path.join(self.workingDir, 'blah 20150101.txt') + filename = os.path.join(self.workingDir, "blah 20150101.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_single_digit_day(self): - filename = os.path.join(self.workingDir, 'blah-2015-01-2.txt') + filename = os.path.join(self.workingDir, "blah-2015-01-2.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_single_digit_month(self): - filename = os.path.join(self.workingDir, 'blah-2015-3-02.txt') + filename = os.path.join(self.workingDir, "blah-2015-3-02.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-03-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-03-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_two_single_digits(self): - filename = os.path.join(self.workingDir, 'blah-2015-3-2.txt') + filename = os.path.join(self.workingDir, "blah-2015-3-2.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-03-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-03-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_two_single_digits_extra(self): - filename = os.path.join(self.workingDir, 'blah-2015-3-2-xyz.txt') + filename = os.path.join(self.workingDir, "blah-2015-3-2-xyz.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-03-02-blah-xyz.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-03-02-blah-xyz.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_full_month_name(self): - filename = os.path.join(self.workingDir, 'Blah 25 January 2015.txt') + filename = os.path.join(self.workingDir, "Blah 25 January 2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-25-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-25-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_full_month_name2(self): - filename = os.path.join(self.workingDir, 'Blah 25 March 2015.txt') + filename = os.path.join(self.workingDir, "Blah 25 March 2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-03-25-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-03-25-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_abbr_month_name(self): - filename = os.path.join(self.workingDir, 'Blah 25 Jan 2015.txt') + filename = os.path.join(self.workingDir, "Blah 25 Jan 2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-25-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-25-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_month_name_year_reversed(self): - filename = os.path.join(self.workingDir, 'Blah May 2015.txt') + filename = os.path.join(self.workingDir, "Blah May 2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-05-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-05-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_day_month_name_year(self): - filename = os.path.join(self.workingDir, 'Blah46_002004_XYZ_20_November_2015.txt') + filename = os.path.join( + self.workingDir, "Blah46_002004_XYZ_20_November_2015.txt" + ) self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-11-20-Blah46_002004_XYZ.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-11-20-Blah46_002004_XYZ.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_abbr_month_insensitive_name(self): - filename = os.path.join(self.workingDir, 'Blah 25 jan 2015.txt') + filename = os.path.join(self.workingDir, "Blah 25 jan 2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-25-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-25-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_abbr_month_insensitive_hyphen_name(self): - filename = os.path.join(self.workingDir, 'Blah_25-feb-2015.txt') + filename = os.path.join(self.workingDir, "Blah_25-feb-2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-02-25-Blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-02-25-Blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_ensure_common_date_separator_used(self): - filename = os.path.join(self.workingDir, 'T 1234 2023-11-22.pdf') + filename = os.path.join(self.workingDir, "T 1234 2023-11-22.pdf") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2023-11-22-T 1234.pdf'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2023-11-22-T 1234.pdf")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_ensure_common_time_separator_used(self): - filename = os.path.join(self.workingDir, 'ABC 2023-11-05T12-13_08.pdf') + filename = os.path.join(self.workingDir, "ABC 2023-11-05T12-13_08.pdf") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2023-11-05T12-13-ABC _08.pdf'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2023-11-05T12-13-ABC _08.pdf") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_earliest(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) - error = self.invokeDirectly([filename], extraParams=['--earliest']) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) + error = self.invokeDirectly([filename], extraParams=["--earliest"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1980-01-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1980-01-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_oldest(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) - error = self.invokeDirectly([filename], extraParams=['--oldest']) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) + error = self.invokeDirectly([filename], extraParams=["--oldest"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1980-01-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1980-01-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_earliest_default(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1980-01-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1980-01-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_latest(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) - error = self.invokeDirectly([filename], extraParams=['--latest']) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) + error = self.invokeDirectly([filename], extraParams=["--latest"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_newest(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) - error = self.invokeDirectly([filename], extraParams=['--newest']) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) + error = self.invokeDirectly([filename], extraParams=["--newest"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_now(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - os.utime(filename, (datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), - datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp())) - error = self.invokeDirectly([filename], extraParams=['--now']) + os.utime( + filename, + ( + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + datetime.datetime(1980, 1, 2, 3, 4, 5).timestamp(), + ), + ) + error = self.invokeDirectly([filename], extraParams=["--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_screenshot(self): - filename = os.path.join(self.workingDir, 'Screen Shot 2015-04-21 at 13.50.45.png') + filename = os.path.join( + self.workingDir, "Screen Shot 2015-04-21 at 13.50.45.png" + ) self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-21T13-50-45-Screen Shot.png'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-21T13-50-45-Screen Shot.png") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_photo(self): - filename = os.path.join(self.workingDir, 'Photo 03-04-2015 12 34 56.png') + filename = os.path.join(self.workingDir, "Photo 03-04-2015 12 34 56.png") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-03T12-34-56-Photo.png'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-03T12-34-56-Photo.png") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_photo_dropbox(self): - filename = os.path.join(self.workingDir, 'Photo 03-04-2015, 12 34 56.png') + filename = os.path.join(self.workingDir, "Photo 03-04-2015, 12 34 56.png") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-03T12-34-56-Photo.png'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-03T12-34-56-Photo.png") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_video(self): - filename = os.path.join(self.workingDir, 'Video 03-04-2015 12 34 56.mov') + filename = os.path.join(self.workingDir, "Video 03-04-2015 12 34 56.mov") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-03T12-34-56-Video.mov'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-03T12-34-56-Video.mov") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_IMG(self): - filename = os.path.join(self.workingDir, 'IMG_20150506_123456.png') + filename = os.path.join(self.workingDir, "IMG_20150506_123456.png") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-05-06T12-34-56-IMG.png'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-05-06T12-34-56-IMG.png")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_VID(self): - filename = os.path.join(self.workingDir, 'VID_20150506_123456.mpg') + filename = os.path.join(self.workingDir, "VID_20150506_123456.mpg") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-05-06T12-34-56-VID.mpg'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-05-06T12-34-56-VID.mpg")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_photo_format2(self): - filename = os.path.join(self.workingDir, 'Photo-2015-04-03-12-34-56.png') + filename = os.path.join(self.workingDir, "Photo-2015-04-03-12-34-56.png") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-03T12-34-56-Photo.png'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-03T12-34-56-Photo.png") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_photo_format2_invalidhour(self): - filename = os.path.join(self.workingDir, 'Photo-2015-04-03-99-34-56.png') + filename = os.path.join(self.workingDir, "Photo-2015-04-03-99-34-56.png") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-03-Photo-99-34-56.png'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-03-Photo-99-34-56.png") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_underscore(self): - filename = os.path.join(self.workingDir, '2008_11_08_15_35_02.txt') + filename = os.path.join(self.workingDir, "2008_11_08_15_35_02.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2008-11-08T15-35-02.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2008-11-08T15-35-02.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_spaces(self): - filename = os.path.join(self.workingDir, '2008 11 08 15 35 02 xyz.txt') + filename = os.path.join(self.workingDir, "2008 11 08 15 35 02 xyz.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2008-11-08T15-35-02 xyz.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2008-11-08T15-35-02 xyz.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_dots(self): - filename = os.path.join(self.workingDir, 'blah 02.04.2015.txt') + filename = os.path.join(self.workingDir, "blah 02.04.2015.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-02-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-04-02-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_startswith_period(self): - filename = os.path.join(self.workingDir, '.blah-2015_01_01.txt') + filename = os.path.join(self.workingDir, ".blah-2015_01_01.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_startswith_period_all(self): - filename = os.path.join(self.workingDir, '.blah-2015_01_01.txt') + filename = os.path.join(self.workingDir, ".blah-2015_01_01.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--all']) + error = self.invokeDirectly([filename], extraParams=["--all"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-.blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-.blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_icon(self): if os.name == "nt": - self.skipTest('Not valid on Windows') + self.skipTest("Not valid on Windows") else: - filename = os.path.join(self.workingDir, 'Icon\r') + filename = os.path.join(self.workingDir, "Icon\r") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'Icon'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "Icon") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_lock(self): - filename = os.path.join(self.workingDir, 'blah.lck') + filename = os.path.join(self.workingDir, "blah.lck") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.lck'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.lck") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_lock_nomatch(self): - filename = os.path.join(self.workingDir, 'blah.lck.blah') + filename = os.path.join(self.workingDir, "blah.lck.blah") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.lck.blah'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.lck.blah") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_exclude_git_file(self): - filename = os.path.join(self.workingDir, '.git', 'bling', 'blah.txt') + filename = os.path.join(self.workingDir, ".git", "bling", "blah.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, '.git', 'bling', self.getDatePrefix() + 'blah.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, '.git', 'bling'))) - self.assertEqual('', error) + self.assertFalse( + os.path.exists( + os.path.join( + self.workingDir, ".git", "bling", self.getDatePrefix() + "blah.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, ".git", "bling")) + ) + self.assertEqual("", error) def test_exclude_nongit_file(self): - filename = os.path.join(self.workingDir, 'xyz', 'bling', 'blah.txt') + filename = os.path.join(self.workingDir, "xyz", "bling", "blah.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'xyz', 'bling', self.getDatePrefix() + 'blah.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'xyz', 'bling'))) - self.assertEqual('', error) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, "xyz", "bling", self.getDatePrefix() + "blah.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, "xyz", "bling")) + ) + self.assertEqual("", error) def test_exclude_subgit_file(self): - filename = os.path.join(self.workingDir, 'xyz', '.git', 'bling', 'blah.txt') + filename = os.path.join(self.workingDir, "xyz", ".git", "bling", "blah.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'xyz', '.git', 'bling', self.getDatePrefix() + 'blah.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'xyz', '.git', 'bling'))) - self.assertEqual('', error) + self.assertFalse( + os.path.exists( + os.path.join( + self.workingDir, + "xyz", + ".git", + "bling", + self.getDatePrefix() + "blah.txt", + ) + ) + ) + self.assertEqual( + 1, + self.directoryFileCount( + os.path.join(self.workingDir, "xyz", ".git", "bling") + ), + ) + self.assertEqual("", error) def test_standardeuropeandate(self): - filename = os.path.join(self.workingDir, 'European XYZ 16052014.pptx') + filename = os.path.join(self.workingDir, "European XYZ 16052014.pptx") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2014-05-16-European XYZ.pptx'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2014-05-16-European XYZ.pptx") + ) + ) self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir))) - self.assertEqual('', error) + self.assertEqual("", error) def test_basicdateprefix_dryrun(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--dry-run']) + error = self.invokeDirectly([filename], extraParams=["--dry-run"]) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertRegex(error, '(?i)not moving.*dry run') + self.assertRegex(error, "(?i)not moving.*dry run") def test_realworld_failure1_now_fixed(self): - filename = os.path.join(self.workingDir, 'Overview 3.0 May 2016.pptx') + filename = os.path.join(self.workingDir, "Overview 3.0 May 2016.pptx") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2016-05-Overview 3.0.pptx'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2016-05-Overview 3.0.pptx")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_zero_month(self): - filename = os.path.join(self.workingDir, 'Overview 5-0-2016.pptx') + filename = os.path.join(self.workingDir, "Overview 5-0-2016.pptx") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'Overview 5-0-2016.pptx'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix() + "Overview 5-0-2016.pptx" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) diff --git a/tests/Direct/test_Direct_Errors.py b/tests/Direct/test_Direct_Errors.py index c8a4d4c..30e3f37 100644 --- a/tests/Direct/test_Direct_Errors.py +++ b/tests/Direct/test_Direct_Errors.py @@ -9,21 +9,27 @@ def setUp(self): super().setUp() def test_file_not_exist(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") with self.assertRaisesRegex(Exception, "does.*.not.*exist"): self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(0, self.directoryFileCount(self.workingDir)) def test_targetfile_exists(self): if os.name == "nt": - self.skipTest("FIXME: This test passes on Windows by " - "inspection, but the automation doesn't work.") + self.skipTest( + "FIXME: This test passes on Windows by " + "inspection, but the automation doesn't work." + ) else: - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.writeFile(filename, "original") - filename2 = os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt') + filename2 = os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") self.writeFile(filename2, "new") with self.assertRaisesRegex(Exception, re.escape(filename2) + ".*exists"): self.invokeDirectly([filename]) @@ -35,12 +41,12 @@ def test_targetfile_exists(self): def test_rename_nopermissions(self): if os.name == "nt": - self.skipTest('Not valid on Windows.') + self.skipTest("Not valid on Windows.") elif self.isRoot(): self.skipTest("Am root.") else: - subdirectory = os.path.join(self.workingDir, 'subdirectory') - filename = os.path.join(subdirectory, 'blah.txt') + subdirectory = os.path.join(self.workingDir, "subdirectory") + filename = os.path.join(subdirectory, "blah.txt") self.touch(filename) self.remove_dir_write_permissions(subdirectory) with self.assertRaisesRegex(Exception, "(?i).*permission denied.*"): diff --git a/tests/Direct/test_Direct_FrozenTime.py b/tests/Direct/test_Direct_FrozenTime.py index a4aa0fc..14ea3d9 100644 --- a/tests/Direct/test_Direct_FrozenTime.py +++ b/tests/Direct/test_Direct_FrozenTime.py @@ -11,110 +11,152 @@ def setUp(self): @freeze_time("2015-02-03 10:11:12") def test_basicdateprefix(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now']) + error = self.invokeDirectly([filename], extraParams=["--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-02-03-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-02-03-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-02-03 10:11:12") def test_basicdateprefix_add_time(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--add-time', '--now']) + error = self.invokeDirectly([filename], extraParams=["--add-time", "--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-02-03T10-11-12-blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-02-03T10-11-12-blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-02-03 10:10:10") def test_ok_behind(self): - filename = os.path.join(self.workingDir, 'blah-1990-02-03.txt') + filename = os.path.join(self.workingDir, "blah-1990-02-03.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1990-02-03-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1990-02-03-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-02-03 10:10:10") def test_ok_ahead(self): - filename = os.path.join(self.workingDir, 'blah-2019-02-03.txt') + filename = os.path.join(self.workingDir, "blah-2019-02-03.txt") self.touch(filename) error = self.invokeDirectly([filename]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2019-02-03-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2019-02-03-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_toofar_behind(self): - filename = os.path.join(self.workingDir, 'blah-1970-02-03.txt') + filename = os.path.join(self.workingDir, "blah-1970-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now']) + error = self.invokeDirectly([filename], extraParams=["--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-05-blah-1970-02-03.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-05-blah-1970-02-03.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_toofar_ahead(self): - filename = os.path.join(self.workingDir, 'blah-2025-02-03.txt') + filename = os.path.join(self.workingDir, "blah-2025-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now']) + error = self.invokeDirectly([filename], extraParams=["--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-05-blah-2025-02-03.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-05-blah-2025-02-03.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_ok_ahead_adjusted(self): - filename = os.path.join(self.workingDir, 'blah-2025-02-03.txt') + filename = os.path.join(self.workingDir, "blah-2025-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now', '--max-years-ahead=50']) + error = self.invokeDirectly( + [filename], extraParams=["--now", "--max-years-ahead=50"] + ) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2025-02-03-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2025-02-03-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_ok_behind_adjusted(self): - filename = os.path.join(self.workingDir, 'blah-1970-02-03.txt') + filename = os.path.join(self.workingDir, "blah-1970-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now', '--max-years-behind=50']) + error = self.invokeDirectly( + [filename], extraParams=["--now", "--max-years-behind=50"] + ) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '1970-02-03-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "1970-02-03-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_toofar_ahead_adjusted(self): - filename = os.path.join(self.workingDir, 'blah-2200-02-03.txt') + filename = os.path.join(self.workingDir, "blah-2200-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now', '--max-years-ahead=50']) + error = self.invokeDirectly( + [filename], extraParams=["--now", "--max-years-ahead=50"] + ) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-05-blah-2200-02-03.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-05-blah-2200-02-03.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:10:10") def test_toofar_behind_adjusted(self): - filename = os.path.join(self.workingDir, 'blah-1930-02-03.txt') + filename = os.path.join(self.workingDir, "blah-1930-02-03.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--now', '--max-years-behind=50']) + error = self.invokeDirectly( + [filename], extraParams=["--now", "--max-years-behind=50"] + ) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-05-blah-1930-02-03.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-05-blah-1930-02-03.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) @freeze_time("2015-04-05 10:11:12") def test_addtime(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - error = self.invokeDirectly([filename], extraParams=['--add-time', '--now']) + error = self.invokeDirectly([filename], extraParams=["--add-time", "--now"]) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-04-05T10-11-12-blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, "2015-04-05T10-11-12-blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) diff --git a/tests/Subprocess/test_Subprocess_Arguments.py b/tests/Subprocess/test_Subprocess_Arguments.py index e0c0f9d..591a68a 100644 --- a/tests/Subprocess/test_Subprocess_Arguments.py +++ b/tests/Subprocess/test_Subprocess_Arguments.py @@ -8,87 +8,121 @@ def setUp(self): super().setUp() def test_no_basicdateprefix(self): - (rc, output, error) = self.invokeAsSubprocess([], extraParams=['--help'], expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + [], extraParams=["--help"], expectOutput=True + ) self.assertEqual(0, rc) self.assertEqual(0, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) def test_verbose(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], extraParams=['--verbose']) + (rc, output, error) = self.invokeAsSubprocess( + [filename], extraParams=["--verbose"] + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertRegex(error, 'moved to') + self.assertEqual("", output) + self.assertRegex(error, "moved to") def test_verbose_impliedby_dryrun(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], extraParams=['--dry-run']) + (rc, output, error) = self.invokeAsSubprocess( + [filename], extraParams=["--dry-run"] + ) self.assertEqual(0, rc) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertRegex(error, '(?i)not moving.*dry run') + self.assertEqual("", output) + self.assertRegex(error, "(?i)not moving.*dry run") def test_recursive_current_directory(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, 'foobar.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, "foobar.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess(['.'], extraParams=['--recursive'], cwd=subWorkingDir) + (rc, output, error) = self.invokeAsSubprocess( + ["."], extraParams=["--recursive"], cwd=subWorkingDir + ) self.assertEqual(0, rc) - self.assertEqual('', error) - newsubWorkingDir = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir') + self.assertEqual("", error) + newsubWorkingDir = os.path.join( + self.workingDir, self.getDatePrefix() + "subWorkingDir" + ) self.assertPathDoesntExist(filename) self.assertPathDoesntExist(subWorkingDir) - self.assertPathExists(os.path.join(newsubWorkingDir, self.getDatePrefix() + 'foobar.txt')) + self.assertPathExists( + os.path.join(newsubWorkingDir, self.getDatePrefix() + "foobar.txt") + ) self.assertEqual(1, self.directoryFileCount(newsubWorkingDir)) def test_recursive_current_directory_interactive(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, 'foobar.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, "foobar.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess(['.'], feedInput=b'ny', - extraParams=['--interactive', '--recursive'], - cwd=subWorkingDir, expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + ["."], + feedInput=b"ny", + extraParams=["--interactive", "--recursive"], + cwd=subWorkingDir, + expectOutput=True, + ) self.assertEqual(0, rc) - self.assertEqual('', error) + self.assertEqual("", error) self.assertPathDoesntExist(filename) self.assertPathExists(subWorkingDir) - self.assertPathExists(os.path.join(subWorkingDir, self.getDatePrefix() + 'foobar.txt')) + self.assertPathExists( + os.path.join(subWorkingDir, self.getDatePrefix() + "foobar.txt") + ) self.assertEqual(1, self.directoryFileCount(subWorkingDir)) def test_recursive_current_directory_interactive_with_dotfile(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, '.bar.txt') - filename2 = os.path.join(subWorkingDir, 'foo.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, ".bar.txt") + filename2 = os.path.join(subWorkingDir, "foo.txt") self.touch(filename) self.touch(filename2) - (rc, output, error) = self.invokeAsSubprocess(['.'], feedInput=b'ny', - extraParams=['--interactive', '--recursive'], - cwd=subWorkingDir, expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + ["."], + feedInput=b"ny", + extraParams=["--interactive", "--recursive"], + cwd=subWorkingDir, + expectOutput=True, + ) self.assertEqual(0, rc) - self.assertEqual('', error) + self.assertEqual("", error) self.assertPathExists(filename) self.assertPathExists(subWorkingDir) self.assertPathDoesntExist(filename2) - self.assertPathExists(os.path.join(subWorkingDir, self.getDatePrefix() + 'foo.txt')) + self.assertPathExists( + os.path.join(subWorkingDir, self.getDatePrefix() + "foo.txt") + ) self.assertEqual(2, self.directoryFileCount(subWorkingDir)) def test_loads_of_files(self): TOTAL_FILES = 100 - filenames = [('filename' + str(i) + '.txt') for i in range(TOTAL_FILES)] + filenames = [("filename" + str(i) + ".txt") for i in range(TOTAL_FILES)] for filename in filenames: self.touch(os.path.join(self.workingDir, filename)) self.assertEqual(TOTAL_FILES, self.directoryFileCount(self.workingDir)) - (rc, output, error) = self.invokeAsSubprocess(filenames, extraParams=['-vv']) + (rc, output, error) = self.invokeAsSubprocess(filenames, extraParams=["-vv"]) self.assertEqual(0, rc) - self.assertNotRegex(error, 'exception') + self.assertNotRegex(error, "exception") self.assertEqual(TOTAL_FILES, self.directoryFileCount(self.workingDir)) for filename in filenames: self.assertPathDoesntExist(os.path.join(self.workingDir, filename)) - self.assertPathExists(os.path.join(self.workingDir, self.getDatePrefix() + filename)) + self.assertPathExists( + os.path.join(self.workingDir, self.getDatePrefix() + filename) + ) diff --git a/tests/Subprocess/test_Subprocess_Basic.py b/tests/Subprocess/test_Subprocess_Basic.py index 3537573..d41fdac 100644 --- a/tests/Subprocess/test_Subprocess_Basic.py +++ b/tests/Subprocess/test_Subprocess_Basic.py @@ -9,297 +9,452 @@ def setUp(self): super().setUp() def test_basicdateprefix(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdateprefix_cwd(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess(['blah.txt'], cwd=self.workingDir) + (rc, output, error) = self.invokeAsSubprocess(["blah.txt"], cwd=self.workingDir) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_nodatemoveneeded(self): - filename = os.path.join(self.workingDir, '2015-01-01-blah.txt') + filename = os.path.join(self.workingDir, "2015-01-01-blah.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertTrue(os.path.exists(filename)) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_nodatemoveneeded2(self): - filename = os.path.join(self.workingDir, '2015-01-01T12-00-00-blah.txt') + filename = os.path.join(self.workingDir, "2015-01-01T12-00-00-blah.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertTrue(os.path.exists(filename)) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_nodatemoveneeded_partial(self): - filename = os.path.join(self.workingDir, '2015-01-blah.txt') + filename = os.path.join(self.workingDir, "2015-01-blah.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertTrue(os.path.exists(filename)) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdatemove(self): - filename = os.path.join(self.workingDir, 'blah-2015-01-01.txt') + filename = os.path.join(self.workingDir, "blah-2015-01-01.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdatemove_partial(self): - filename = os.path.join(self.workingDir, 'blah-2015-01.txt') + filename = os.path.join(self.workingDir, "blah-2015-01.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_datemove_partial(self): - filename = os.path.join(self.workingDir, 'blah-2015-01-bling.txt') + filename = os.path.join(self.workingDir, "blah-2015-01-bling.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-blah-bling.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-blah-bling.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdatemove_underscore(self): - filename = os.path.join(self.workingDir, 'blah_2015_01_01.txt') + filename = os.path.join(self.workingDir, "blah_2015_01_01.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdatemove2(self): - filename = os.path.join(self.workingDir, 'blah-2015-01-01-bling.txt') + filename = os.path.join(self.workingDir, "blah-2015-01-01-bling.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah-bling.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah-bling.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdatemove2_underscore(self): - filename = os.path.join(self.workingDir, 'blah_2015_01_01_bling.txt') + filename = os.path.join(self.workingDir, "blah_2015_01_01_bling.txt") self.touch(filename) (rc, output, error) = self.invokeAsSubprocess([filename]) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01-blah_bling.txt'))) + self.assertTrue( + os.path.exists(os.path.join(self.workingDir, "2015-01-01-blah_bling.txt")) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_basicdateprefix_interactive_yes(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], feedInput=b'y', extraParams=['--interactive'], expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + [filename], feedInput=b"y", extraParams=["--interactive"], expectOutput=True + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertRegex(output, 'Move ' + re.escape(filename) + '.*') - self.assertEqual('', error) + self.assertRegex(output, "Move " + re.escape(filename) + ".*") + self.assertEqual("", error) def test_basicdateprefix_interactive_no(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], feedInput=b'n', extraParams=['--interactive'], expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + [filename], feedInput=b"n", extraParams=["--interactive"], expectOutput=True + ) self.assertEqual(0, rc) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertRegex(output, 'Move ' + re.escape(filename) + '.*') - self.assertEqual('', error) + self.assertRegex(output, "Move " + re.escape(filename) + ".*") + self.assertEqual("", error) def test_basicdateprefix_interactive_oneyesoneno(self): - filename = os.path.join(self.workingDir, 'blah.txt') - filename2 = os.path.join(self.workingDir, 'blah2.txt') + filename = os.path.join(self.workingDir, "blah.txt") + filename2 = os.path.join(self.workingDir, "blah2.txt") self.touch(filename) self.touch(filename2) - (rc, output, error) = self.invokeAsSubprocess([filename, filename2], feedInput=b'yn', extraParams=['--interactive'], - expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + [filename, filename2], + feedInput=b"yn", + extraParams=["--interactive"], + expectOutput=True, + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) self.assertTrue(os.path.exists(filename2)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah2.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah2.txt") + ) + ) self.assertEqual(2, self.directoryFileCount(self.workingDir)) - self.assertRegex(output, '(?is)Move ' + re.escape(filename) + ".*Move " + re.escape(filename2) + '.*') - self.assertEqual('', error) + self.assertRegex( + output, + "(?is)Move " + + re.escape(filename) + + ".*Move " + + re.escape(filename2) + + ".*", + ) + self.assertEqual("", error) def test_basicdateprefix_interactive_oneyesquit(self): - filename = os.path.join(self.workingDir, 'blah.txt') - filename2 = os.path.join(self.workingDir, 'blah2.txt') - filename3 = os.path.join(self.workingDir, 'blah3.txt') + filename = os.path.join(self.workingDir, "blah.txt") + filename2 = os.path.join(self.workingDir, "blah2.txt") + filename3 = os.path.join(self.workingDir, "blah3.txt") self.touch(filename) self.touch(filename2) self.touch(filename3) - (rc, output, error) = self.invokeAsSubprocess([filename, filename2, filename3], - feedInput=b'yqy', extraParams=['--interactive'], - expectOutput=True) + (rc, output, error) = self.invokeAsSubprocess( + [filename, filename2, filename3], + feedInput=b"yqy", + extraParams=["--interactive"], + expectOutput=True, + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) self.assertTrue(os.path.exists(filename2)) self.assertTrue(os.path.exists(filename3)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah2.txt'))) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah3.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah2.txt") + ) + ) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah3.txt") + ) + ) self.assertEqual(3, self.directoryFileCount(self.workingDir)) - self.assertRegex(output, '(?is)Move ' + re.escape(filename) + '.*Move ' + re.escape(filename2) + '.*') - self.assertEqual('', error) + self.assertRegex( + output, + "(?is)Move " + + re.escape(filename) + + ".*Move " + + re.escape(filename2) + + ".*", + ) + self.assertEqual("", error) def test_basicdateprefix_interactive_edit(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - with self.invokeAsPexpect([filename], extraParams=['--interactive'], - expectedExitStatus=0, - expectedOutputRegex='Move ' + re.escape(filename) + '.*') as child: - child.expect(']? ') - child.send('e') + with self.invokeAsPexpect( + [filename], + extraParams=["--interactive"], + expectedExitStatus=0, + expectedOutputRegex="Move " + re.escape(filename) + ".*", + ) as child: + child.expect("]? ") + child.send("e") child.expect("filename\\? ") for i in range(19): - child.sendcontrol('H') - child.send('bling.txt\n') + child.sendcontrol("H") + child.send("bling.txt\n") self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'bling.txt'))) + self.assertTrue(os.path.exists(os.path.join(self.workingDir, "bling.txt"))) self.assertEqual(1, self.directoryFileCount(self.workingDir)) def test_logfile(self): - filename = os.path.join(self.workingDir, 'blah.txt') - filename2 = os.path.join(self.workingDir, 'blah2.txt') + filename = os.path.join(self.workingDir, "blah.txt") + filename2 = os.path.join(self.workingDir, "blah2.txt") self.touch(filename) self.touch(filename2) - (rc, output, error, undo_log_lines) = self.invokeAsSubprocess([filename, filename2], - useUndoFile=True) + (rc, output, error, undo_log_lines) = self.invokeAsSubprocess( + [filename, filename2], useUndoFile=True + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) self.assertFalse(os.path.exists(filename2)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah2.txt'))) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) + self.assertTrue( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah2.txt") + ) + ) self.assertEqual(2, self.directoryFileCount(self.workingDir)) - self.assertEqual('', error) + self.assertEqual("", error) self.assertEqual(0, self.executeUndoCommands(undo_log_lines)) self.assertTrue(os.path.exists(filename)) self.assertTrue(os.path.exists(filename2)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah.txt'))) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix() + 'blah2.txt'))) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah.txt") + ) + ) + self.assertFalse( + os.path.exists( + os.path.join(self.workingDir, self.getDatePrefix() + "blah2.txt") + ) + ) self.assertEqual(2, self.directoryFileCount(self.workingDir)) def test_logfile_with_spaces(self): - filename = os.path.join(self.workingDir, 'sub dir', 'foo bar.txt') + filename = os.path.join(self.workingDir, "sub dir", "foo bar.txt") self.touch(filename) - (rc, output, error, undo_log_lines) = self.invokeAsSubprocess([filename], - useUndoFile=True) + (rc, output, error, undo_log_lines) = self.invokeAsSubprocess( + [filename], useUndoFile=True + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'sub dir', self.getDatePrefix() + 'foo bar.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'sub dir'))) - self.assertEqual('', error) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, "sub dir", self.getDatePrefix() + "foo bar.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, "sub dir")) + ) + self.assertEqual("", error) self.assertEqual(0, self.executeUndoCommands(undo_log_lines)) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'sub dir', self.getDatePrefix() + 'foo bar.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'sub dir'))) + self.assertFalse( + os.path.exists( + os.path.join( + self.workingDir, "sub dir", self.getDatePrefix() + "foo bar.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, "sub dir")) + ) def test_logfile_with_single_quotes(self): - filename = os.path.join(self.workingDir, 'sub\'dir', 'foo\'bar.txt') + filename = os.path.join(self.workingDir, "sub'dir", "foo'bar.txt") self.touch(filename) - (rc, output, error, undo_log_lines) = self.invokeAsSubprocess([filename], - useUndoFile=True) + (rc, output, error, undo_log_lines) = self.invokeAsSubprocess( + [filename], useUndoFile=True + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, 'sub\'dir', self.getDatePrefix() + 'foo\'bar.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'sub\'dir'))) - self.assertEqual('', error) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, "sub'dir", self.getDatePrefix() + "foo'bar.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, "sub'dir")) + ) + self.assertEqual("", error) self.assertEqual(0, self.executeUndoCommands(undo_log_lines)) self.assertTrue(os.path.exists(filename)) - self.assertFalse(os.path.exists(os.path.join(self.workingDir, 'sub\'dir', self.getDatePrefix() + 'foo\'bar.txt'))) - self.assertEqual(1, self.directoryFileCount(os.path.join(self.workingDir, 'sub\'dir'))) + self.assertFalse( + os.path.exists( + os.path.join( + self.workingDir, "sub'dir", self.getDatePrefix() + "foo'bar.txt" + ) + ) + ) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(self.workingDir, "sub'dir")) + ) def test_directory_withfiles_recursive_logfile(self): - subWorkingDir = os.path.join(self.workingDir, 'subWorkingDir') - filename = os.path.join(subWorkingDir, 'blah_2015_01_01_bling.txt') + subWorkingDir = os.path.join(self.workingDir, "subWorkingDir") + filename = os.path.join(subWorkingDir, "blah_2015_01_01_bling.txt") self.touch(filename) - filename2 = os.path.join(subWorkingDir, 'xyz-2015-03-04.txt') + filename2 = os.path.join(subWorkingDir, "xyz-2015-03-04.txt") self.touch(filename2) - filename3 = os.path.join(subWorkingDir, 'subWorkingDir2', 'abc-2015-03-04.txt') + filename3 = os.path.join(subWorkingDir, "subWorkingDir2", "abc-2015-03-04.txt") self.touch(filename3) - (rc, output, error, undo_log_lines) = self.invokeAsSubprocess([subWorkingDir], - extraParams=['--recursive'], useUndoFile=True) + (rc, output, error, undo_log_lines) = self.invokeAsSubprocess( + [subWorkingDir], extraParams=["--recursive"], useUndoFile=True + ) self.assertEqual(0, rc) - self.assertEqual('', error) - newsubWorkingDir = os.path.join(self.workingDir, self.getDatePrefix() + 'subWorkingDir') + self.assertEqual("", error) + newsubWorkingDir = os.path.join( + self.workingDir, self.getDatePrefix() + "subWorkingDir" + ) self.assertPathDoesntExist(filename) self.assertPathDoesntExist(filename2) self.assertPathDoesntExist(filename3) - self.assertPathExists(os.path.join(newsubWorkingDir, '2015-01-01-blah_bling.txt')) - self.assertPathExists(os.path.join(newsubWorkingDir, '2015-03-04-xyz.txt')) - self.assertPathExists(os.path.join(newsubWorkingDir, self.getDatePrefix() + 'subWorkingDir2', '2015-03-04-abc.txt')) + self.assertPathExists( + os.path.join(newsubWorkingDir, "2015-01-01-blah_bling.txt") + ) + self.assertPathExists(os.path.join(newsubWorkingDir, "2015-03-04-xyz.txt")) + self.assertPathExists( + os.path.join( + newsubWorkingDir, + self.getDatePrefix() + "subWorkingDir2", + "2015-03-04-abc.txt", + ) + ) self.assertEqual(2, self.directoryFileCount(newsubWorkingDir)) - self.assertEqual(1, self.directoryFileCount(os.path.join(newsubWorkingDir, self.getDatePrefix() + 'subWorkingDir2'))) + self.assertEqual( + 1, + self.directoryFileCount( + os.path.join(newsubWorkingDir, self.getDatePrefix() + "subWorkingDir2") + ), + ) self.assertEqual(0, self.executeUndoCommands(undo_log_lines)) self.assertPathDoesntExist(newsubWorkingDir) self.assertPathExists(filename) self.assertPathExists(filename2) self.assertPathExists(filename3) self.assertEqual(2, self.directoryFileCount(subWorkingDir)) - self.assertEqual(1, self.directoryFileCount(os.path.join(subWorkingDir, 'subWorkingDir2'))) + self.assertEqual( + 1, self.directoryFileCount(os.path.join(subWorkingDir, "subWorkingDir2")) + ) def test_discardprevioussuffix(self): - filename = os.path.join(self.workingDir, 'blah.txt') + filename = os.path.join(self.workingDir, "blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], extraParams=['--discard-existing-name']) + (rc, output, error) = self.invokeAsSubprocess( + [filename], extraParams=["--discard-existing-name"] + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, self.getDatePrefix(postfixDash=False) + '.txt'))) + self.assertTrue( + os.path.exists( + os.path.join( + self.workingDir, self.getDatePrefix(postfixDash=False) + ".txt" + ) + ) + ) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error) def test_discardprevioussuffix_existingdate(self): - filename = os.path.join(self.workingDir, '2015-01-01-blah.txt') + filename = os.path.join(self.workingDir, "2015-01-01-blah.txt") self.touch(filename) - (rc, output, error) = self.invokeAsSubprocess([filename], extraParams=['--discard-existing-name']) + (rc, output, error) = self.invokeAsSubprocess( + [filename], extraParams=["--discard-existing-name"] + ) self.assertEqual(0, rc) self.assertFalse(os.path.exists(filename)) - self.assertTrue(os.path.exists(os.path.join(self.workingDir, '2015-01-01.txt'))) + self.assertTrue(os.path.exists(os.path.join(self.workingDir, "2015-01-01.txt"))) self.assertEqual(1, self.directoryFileCount(self.workingDir)) - self.assertEqual('', output) - self.assertEqual('', error) + self.assertEqual("", output) + self.assertEqual("", error)