Re-ordered tests/test_walk.py to give more structure to the test cases and remove code duplication.

Author: atollk

tests/test_walk.py

@@ -21,9 +21,28 @@ def test_create(self):
             walk.Walker(ignore_errors=True, on_error=lambda path, error: True)
         walk.Walker(ignore_errors=True)
 
+    def test_on_error_invalid(self):
+        with self.assertRaises(TypeError):
+            walk.Walker(on_error="nope")
 
-class TestWalk(unittest.TestCase):
+
+class TestBoundWalkerBase(unittest.TestCase):
     def setUp(self):
+        """
+        Sets up the following file system with empty files:
+
+        /
+        -foo1/
+        -    -top1.txt
+        -    -top2.txt
+        -foo2/
+        -    -bar1/
+        -    -bar2/
+        -    -    -bar3/
+        -    -    -    -test.txt
+        -    -top3.bin
+        -foo3/
+        """
         self.fs = MemoryFS()
 
         self.fs.makedir("foo1")
@@ -37,21 +56,50 @@ def setUp(self):
         self.fs.create("foo2/bar2/bar3/test.txt")
         self.fs.create("foo2/top3.bin")
 
-    def test_invalid(self):
-        with self.assertRaises(ValueError):
-            self.fs.walk(search="random")
 
+class TestBoundWalker(TestBoundWalkerBase):
     def test_repr(self):
         repr(self.fs.walk)
 
-    def test_walk(self):
+    def test_readonly_wrapper_uses_same_walker(self):
+        class CustomWalker(walk.Walker):
+            @classmethod
+            def bind(cls, fs):
+                return walk.BoundWalker(fs, walker_class=CustomWalker)
+
+        class CustomizedMemoryFS(MemoryFS):
+            walker_class = CustomWalker
+
+        base_fs = CustomizedMemoryFS()
+        base_walker = base_fs.walk
+        self.assertEqual(base_walker.walker_class, CustomWalker)
+
+        readonly_fs = read_only(CustomizedMemoryFS())
+        readonly_walker = readonly_fs.walk
+        self.assertEqual(readonly_walker.walker_class, CustomWalker)
+
+
+class TestWalk(TestBoundWalkerBase):
+    def _walk_step_names(self, *args, **kwargs):
+        """Performs a walk with the given arguments and returns a list of steps.
+
+        Each step is a triple of the path, list of directory names, and list of file names.
+        """
         _walk = []
-        for step in self.fs.walk():
+        for step in self.fs.walk(*args, **kwargs):
             self.assertIsInstance(step, walk.Step)
             path, dirs, files = step
             _walk.append(
                 (path, [info.name for info in dirs], [info.name for info in files])
             )
+        return _walk
+
+    def test_invalid_search(self):
+        with self.assertRaises(ValueError):
+            self.fs.walk(search="random")
+
+    def test_walk(self):
+        _walk = self._walk_step_names()
         expected = [
             ("/", ["foo1", "foo2", "foo3"], []),
             ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
@@ -64,13 +112,7 @@ def test_walk(self):
         self.assertEqual(_walk, expected)
 
     def test_walk_filter_dirs(self):
-        _walk = []
-        for step in self.fs.walk(filter_dirs=["foo*"]):
-            self.assertIsInstance(step, walk.Step)
-            path, dirs, files = step
-            _walk.append(
-                (path, [info.name for info in dirs], [info.name for info in files])
-            )
+        _walk = self._walk_step_names(filter_dirs=["foo*"])
         expected = [
             ("/", ["foo1", "foo2", "foo3"], []),
             ("/foo1", [], ["top1.txt", "top2.txt"]),
@@ -80,13 +122,7 @@ def test_walk_filter_dirs(self):
         self.assertEqual(_walk, expected)
 
     def test_walk_depth(self):
-        _walk = []
-        for step in self.fs.walk(search="depth"):
-            self.assertIsInstance(step, walk.Step)
-            path, dirs, files = step
-            _walk.append(
-                (path, [info.name for info in dirs], [info.name for info in files])
-            )
+        _walk = self._walk_step_names(search="depth")
         expected = [
             ("/foo1/bar1", [], []),
             ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
@@ -99,13 +135,7 @@ def test_walk_depth(self):
         self.assertEqual(_walk, expected)
 
     def test_walk_directory(self):
-        _walk = []
-        for step in self.fs.walk("foo2"):
-            self.assertIsInstance(step, walk.Step)
-            path, dirs, files = step
-            _walk.append(
-                (path, [info.name for info in dirs], [info.name for info in files])
-            )
+        _walk = self._walk_step_names("foo2")
         expected = [
             ("/foo2", ["bar2"], ["top3.bin"]),
             ("/foo2/bar2", ["bar3"], []),
@@ -114,33 +144,21 @@ def test_walk_directory(self):
         self.assertEqual(_walk, expected)
 
     def test_walk_levels_1(self):
-        results = list(self.fs.walk(max_depth=1))
-        self.assertEqual(len(results), 1)
-        dirs = sorted(info.name for info in results[0].dirs)
-        self.assertEqual(dirs, ["foo1", "foo2", "foo3"])
-        files = sorted(info.name for info in results[0].files)
-        self.assertEqual(files, [])
+        _walk = self._walk_step_names(max_depth=1)
+        expected = [
+            ("/", ["foo1", "foo2", "foo3"], []),
+        ]
+        self.assertEqual(_walk, expected)
 
     def test_walk_levels_1_depth(self):
-        results = list(self.fs.walk(max_depth=1, search="depth"))
-        self.assertEqual(len(results), 1)
-        dirs = sorted(info.name for info in results[0].dirs)
-        self.assertEqual(dirs, ["foo1", "foo2", "foo3"])
-        files = sorted(info.name for info in results[0].files)
-        self.assertEqual(files, [])
+        _walk = self._walk_step_names(max_depth=1)
+        expected = [
+            ("/", ["foo1", "foo2", "foo3"], []),
+        ]
+        self.assertEqual(_walk, expected)
 
     def test_walk_levels_2(self):
-        _walk = []
-        for step in self.fs.walk(max_depth=2):
-            self.assertIsInstance(step, walk.Step)
-            path, dirs, files = step
-            _walk.append(
-                (
-                    path,
-                    sorted(info.name for info in dirs),
-                    sorted(info.name for info in files),
-                )
-            )
+        _walk = self._walk_step_names(max_depth=2)
         expected = [
             ("/", ["foo1", "foo2", "foo3"], []),
             ("/foo1", ["bar1"], ["top1.txt", "top2.txt"]),
@@ -149,6 +167,26 @@ def test_walk_levels_2(self):
         ]
         self.assertEqual(_walk, expected)
 
+
+class TestDirs(TestBoundWalkerBase):
+    def test_walk_dirs(self):
+        dirs = list(self.fs.walk.dirs())
+        self.assertEqual(
+            dirs,
+            ["/foo1", "/foo2", "/foo3", "/foo1/bar1", "/foo2/bar2", "/foo2/bar2/bar3"],
+        )
+
+        dirs = list(self.fs.walk.dirs(search="depth"))
+        self.assertEqual(
+            dirs,
+            ["/foo1/bar1", "/foo1", "/foo2/bar2/bar3", "/foo2/bar2", "/foo2", "/foo3"],
+        )
+
+        dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=["foo2"]))
+        self.assertEqual(dirs, ["/foo1/bar1", "/foo1", "/foo3"])
+
+
+class TestFiles(TestBoundWalkerBase):
     def test_walk_files(self):
         files = list(self.fs.walk.files())
 
@@ -173,22 +211,6 @@ def test_walk_files(self):
             ],
         )
 
-    def test_walk_dirs(self):
-        dirs = list(self.fs.walk.dirs())
-        self.assertEqual(
-            dirs,
-            ["/foo1", "/foo2", "/foo3", "/foo1/bar1", "/foo2/bar2", "/foo2/bar2/bar3"],
-        )
-
-        dirs = list(self.fs.walk.dirs(search="depth"))
-        self.assertEqual(
-            dirs,
-            ["/foo1/bar1", "/foo1", "/foo2/bar2/bar3", "/foo2/bar2", "/foo2", "/foo3"],
-        )
-
-        dirs = list(self.fs.walk.dirs(search="depth", exclude_dirs=["foo2"]))
-        self.assertEqual(dirs, ["/foo1/bar1", "/foo1", "/foo3"])
-
     def test_walk_files_filter(self):
         files = list(self.fs.walk.files(filter=["*.txt"]))
 
@@ -222,25 +244,6 @@ def test_walk_files_exclude(self):
         files = list(self.fs.walk.files(exclude=["*"]))
         self.assertEqual(files, [])
 
-    def test_walk_info(self):
-        walk = []
-        for path, info in self.fs.walk.info():
-            walk.append((path, info.is_dir, info.name))
-
-        expected = [
-            ("/foo1", True, "foo1"),
-            ("/foo2", True, "foo2"),
-            ("/foo3", True, "foo3"),
-            ("/foo1/top1.txt", False, "top1.txt"),
-            ("/foo1/top2.txt", False, "top2.txt"),
-            ("/foo1/bar1", True, "bar1"),
-            ("/foo2/bar2", True, "bar2"),
-            ("/foo2/top3.bin", False, "top3.bin"),
-            ("/foo2/bar2/bar3", True, "bar3"),
-            ("/foo2/bar2/bar3/test.txt", False, "test.txt"),
-        ]
-        self.assertEqual(walk, expected)
-
     def test_broken(self):
         original_scandir = self.fs.scandir
 
@@ -257,10 +260,6 @@ def broken_scandir(path, namespaces=None):
         with self.assertRaises(FSError):
             list(self.fs.walk.files(on_error=lambda path, error: False))
 
-    def test_on_error_invalid(self):
-        with self.assertRaises(TypeError):
-            walk.Walker(on_error="nope")
-
     def test_subdir_uses_same_walker(self):
         class CustomWalker(walk.Walker):
             @classmethod
@@ -284,19 +283,23 @@ class CustomizedMemoryFS(MemoryFS):
         self.assertEqual(sub_walker.walker_class, CustomWalker)
         six.assertCountEqual(self, ["/c", "/d"], sub_walker.files())
 
-    def test_readonly_wrapper_uses_same_walker(self):
-        class CustomWalker(walk.Walker):
-            @classmethod
-            def bind(cls, fs):
-                return walk.BoundWalker(fs, walker_class=CustomWalker)
-
-        class CustomizedMemoryFS(MemoryFS):
-            walker_class = CustomWalker
 
-        base_fs = CustomizedMemoryFS()
-        base_walker = base_fs.walk
-        self.assertEqual(base_walker.walker_class, CustomWalker)
+class TestInfo(TestBoundWalkerBase):
+    def test_walk_info(self):
+        walk = []
+        for path, info in self.fs.walk.info():
+            walk.append((path, info.is_dir, info.name))
 
-        readonly_fs = read_only(CustomizedMemoryFS())
-        readonly_walker = readonly_fs.walk
-        self.assertEqual(readonly_walker.walker_class, CustomWalker)
+        expected = [
+            ("/foo1", True, "foo1"),
+            ("/foo2", True, "foo2"),
+            ("/foo3", True, "foo3"),
+            ("/foo1/top1.txt", False, "top1.txt"),
+            ("/foo1/top2.txt", False, "top2.txt"),
+            ("/foo1/bar1", True, "bar1"),
+            ("/foo2/bar2", True, "bar2"),
+            ("/foo2/top3.bin", False, "top3.bin"),
+            ("/foo2/bar2/bar3", True, "bar3"),
+            ("/foo2/bar2/bar3/test.txt", False, "test.txt"),
+        ]
+        self.assertEqual(walk, expected)