[Test] Extend test for watch (#299)

Author: jan-janssen

src/pyfileindex/pyfileindex.py

@@ -40,7 +40,12 @@ def __init__(
         if watch:
             self._watcher = FileSystemWatcher(path=self._path)
             self._watcher.start()
-        if df is None:
+        if df is None or watch:
+            # A df handed down from a parent index (e.g. via open()) can be
+            # stale: the parent's watcher may not have drained changes made
+            # to this path yet, and a freshly started watcher here only
+            # reports changes from now on, so a missing entry would never be
+            # backfilled. Scanning is cheap relative to that permanent loss.
             self._df = self._create_df_from_lst(
                 [self._get_lst_entry_from_path(entry=self._path)]
                 + list(self._scandir(path=self._path, df=None, recursive=True))

tests/unit/test_watchfiles.py

@@ -153,6 +153,41 @@ def test_open_propagates_watch_flag(self):
         finally:
             os.rmdir(sub_dir)
 
+    def test_open_backfills_files_missed_by_stale_parent_snapshot(self):
+        """
+        Regression test for a permanent-loss race: open() hands the child a
+        snapshot filtered from the parent's dataframe, which can be stale if
+        the parent's background watcher has not drained a recent change yet.
+        A freshly started child watcher only reports changes from the moment
+        it starts, so if the child trusted that stale snapshot instead of
+        scanning the directory itself, a file that already existed before
+        the child started watching would be permanently invisible to it --
+        no amount of retrying update() afterwards would ever recover it.
+        """
+        sub_dir = os.path.join(self.path, "sub_stale")
+        os.makedirs(sub_dir)
+        nested_file = os.path.join(sub_dir, "nested.txt")
+        touch(nested_file)
+
+        # Simulate the parent's watcher not having drained the change yet by
+        # making its update() a no-op for the duration of open(), so the
+        # parent's df does not contain `nested_file` (or even `sub_dir`)
+        # when it gets filtered for the child.
+        with patch.object(self.fi, "update", lambda timeout=0.1: None):
+            self.assertNotIn(sub_dir, self.fi.df.path.values)
+            fi_sub = self.fi.open(sub_dir)
+        try:
+            self.assertIn(
+                nested_file,
+                fi_sub.df.path.values,
+                msg="open() must not rely solely on a (possibly stale) "
+                "snapshot filtered from the parent's dataframe -- a freshly "
+                "started child watcher can never backfill a file that "
+                "already existed before it started watching.",
+            )
+        finally:
+            fi_sub.close()
+
 
 class TestApplyWatchChanges(unittest.TestCase):
     @classmethod