lambda-watcher 0.2.0__tar.gz → 0.2.1__tar.gz

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.2.0
+Version: 0.2.1
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lambda-watcher"
-version = "0.2.0"
+version = "0.2.1"
 description = "Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions."
 readme = "README.md"
 requires-python = ">=3.10"

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/__init__.py

@@ -1,4 +1,4 @@
 """Watch a downloads folder for AWS Lambda deployment packages and version them."""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 __all__ = ["__version__"]

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/cli.py

@@ -11,7 +11,7 @@ import sys
 import webbrowser
 import zipfile
 from datetime import datetime, timezone
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import NoReturn, Optional
 
 import typer
@@ -36,7 +36,7 @@ from .service import (
     install_service,
     stop_service,
 )
-from .store import Store
+from .store import Store, posix_stored_dir
 from .utils import format_ts, human_size, relative_ts, rmtree, setup_logging, slugify
 
 #: Index connections opened by the running command; see `_close_open_dbs`.
@@ -187,6 +187,19 @@ def _version_or_fail(db: Database, function_id: int, seq: int):
     return row
 
 
+def _stored_dirname(stored_dir: str) -> str:
+    """The last segment of a version's stored path: ``0007-a1b2c3d4``.
+
+    Goes through :func:`~lambda_watcher.store.posix_stored_dir` first, so it
+    reads the same answer out of a value an older release wrote on Windows —
+    where ``Path(...).name`` on Linux returns the whole backslash-joined string
+    instead of the directory name, and the caller then builds a path to nothing.
+    """
+    # back-compat: `posix_stored_dir` is the whole point of this helper existing
+    # rather than callers reaching for `Path(...).name` themselves.
+    return PurePosixPath(posix_stored_dir(stored_dir)).name
+
+
 def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: int, b_seq: int,
                 include_vendor: bool | None, compute_diffs: bool = True):
     """Resolve two versions and build the diff between them.
@@ -194,7 +207,10 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
     Warns, rather than fails, when a version's extracted code is missing from
     disk: the index still knows what changed at the file level, so the summary
     and dependency layers are worth printing even though the line diffs come out
-    empty. Deleting an archive directory by hand is the usual cause.
+    empty. Deleting an archive directory by hand is one cause; an index pointing
+    somewhere the directory no longer is, after the archive was moved or copied
+    from another machine, is the other — which is why the warning names
+    ``lw reindex``, the command that rebuilds the index from what is on disk.
     """
     a = _version_or_fail(db, function_row["id"], a_seq)
     b = _version_or_fail(db, function_row["id"], b_seq)
@@ -203,7 +219,8 @@ def _build_diff(db: Database, store: Store, cfg: Config, function_row, a_seq: in
         if not path.exists():
             err_console.print(
                 f"[yellow]warning:[/yellow] code for v{seq:04d} is missing at {path}; "
-                "line diffs for it will be empty"
+                "line diffs for it will be empty. If the archive was moved or copied "
+                "here, `lw reindex` re-points the index at what is on disk."
             )
     return diff_from_index(db, store, cfg.diff, function_row["name"], a, b,
                            include_vendor=include_vendor, compute_diffs=compute_diffs)
@@ -1128,8 +1145,15 @@ def rename(
         if new_dir.exists():
             _fail(f"{new_dir} already exists on disk; move it aside first")
         old_dir.rename(new_dir)
+        # back-compat: re-point the index by rebuilding each path from where the
+        # directory now is, rather than by patching the stored string. A
+        # `functions/<old slug>/` replacement silently matched nothing in an
+        # archive an older release wrote on Windows, where the separator is a
+        # backslash — and a version left pointing at the pre-rename path reads
+        # as missing from then on, which is a diff with no lines in it.
+        new_versions = store.versions_dir(new_slug)
         for version in db.list_versions(int(row["id"])):
-            updated = version["dir"].replace(f"functions/{old_slug}/", f"functions/{new_slug}/", 1)
+            updated = store.relative(new_versions / _stored_dirname(version["dir"]))
             db.conn.execute("UPDATE versions SET dir = ? WHERE id = ?", (updated, version["id"]))
     if old_slug != new_slug:
         # The mirror lives outside the function directory, so it does not move
@@ -1209,7 +1233,7 @@ def merge(
         stored = store.resolve_version_dir(version["dir"])
         if stored.exists():
             continue
-        candidate = dst_versions / Path(version["dir"]).name
+        candidate = dst_versions / _stored_dirname(version["dir"])
         if candidate.exists():
             db.conn.execute(
                 "UPDATE versions SET dir = ? WHERE id = ?",

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/diffing/compare.py

@@ -38,7 +38,15 @@ class FileRecord:
 
     @classmethod
     def from_row(cls, row: Any) -> FileRecord:
-        """Build a record from an index row, filling in defaults for null columns."""
+        """Build a record from an index row, filling in defaults for null columns.
+
+        The defaults are not decoration: a row reindexed from a manifest written
+        before ``lang`` and ``mode`` were recorded has NULL in those columns, and
+        the diff would rather call the file ``text`` at 644 than fail on it.
+        """
+        # back-compat: `or "text"` / `or 0o644` cover columns an older manifest
+        # cannot fill. Drop them and reindexing an old archive builds rows that
+        # crash the diff instead of one that is merely vaguer than it could be.
         return cls(
             path=row["path"], size=int(row["size"]), sha256=row["sha256"],
             is_text=bool(row["is_text"]), is_vendor=bool(row["is_vendor"]),
@@ -56,8 +64,9 @@ class FileChange:
 
     ``diff_lines`` may be empty even for a real modification —
     ``skipped_reason`` then says why (binary, too large, ignored by config,
-    whitespace only), so the renderer can explain the absence rather than imply
-    nothing changed. Two of those absences are not refusals but better answers:
+    whitespace only, missing from the archive), so the renderer can explain the
+    absence rather than imply nothing changed. Two of those absences are not
+    refusals but better answers:
     a whitespace-only change is fully described by its label, and a file with no
     usable lines is described by ``word_edits`` instead. See :func:`_fill_diff`.
     """
@@ -87,6 +96,12 @@ class FileChange:
     #: The changed runs of a ``long_lines`` file, with enough text either side to
     #: place them. Empty for every ordinary file.
     word_edits: list[WordEdit] = field(default_factory=list)
+    #: True when the index lists the file but the archived version directory does
+    #: not hold it, so there was nothing to diff. Unlike every other reason a
+    #: hunk is absent, this one is not about the file at all — the archive is
+    #: incomplete, or the index is pointing at the wrong place — so the
+    #: renderers say what to do about it rather than only what happened.
+    missing: bool = False
 
     @property
     def is_vendor(self) -> bool:
@@ -146,6 +161,7 @@ class FileChange:
             "is_vendor": self.is_vendor,
             "whitespace_only": self.whitespace_only,
             "long_lines": self.long_lines,
+            "missing": self.missing,
             "word_edits": [e.as_dict() for e in self.word_edits],
         }
 
@@ -764,6 +780,21 @@ def _whitespace_key(text: str) -> tuple[str, ...]:
     return tuple(" ".join(line.split()) for line in text.splitlines() if line.strip())
 
 
+def _absent(root: Path, record: FileRecord | None) -> bool:
+    """True when the index lists this file but the archive no longer holds it.
+
+    :func:`~lambda_watcher.utils.read_text` answers None both for bytes that are
+    not text and for a file it could not open at all, and the second is by far
+    the likelier of the two here: the index is derived from disk, so a file it
+    lists was readable when it was written. A version directory that has been
+    deleted, moved, or restored under a path the index does not know about is
+    what actually produces it — see :meth:`lambda_watcher.store.Store.relative`.
+    Telling the reader "not decodable as text" for that sends them looking for an
+    encoding problem in a file that is simply not there.
+    """
+    return record is not None and not (root / record.path).is_file()
+
+
 def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConfig) -> None:
     """Work out what changed inside one file and write it onto the change.
 
@@ -792,7 +823,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
         Everything else, from :func:`difflib.unified_diff`.
 
     Before any of that, a file can be refused outright — binary, over
-    ``max_diff_file_kb``, or not decodable — and ``skipped_reason`` says which.
+    ``max_diff_file_kb``, not decodable, or missing from the archive — and
+    ``skipped_reason`` says which. The last of those is not a property of the
+    file's bytes but of the archive around it, so it is told apart by
+    :func:`_absent` rather than lumped in with the encodings.
     Line counts stay at zero on every route but the last: the counts describe a
     hunk, and where there is no hunk ``+3/-3`` is the noise the route exists to
     remove.
@@ -813,7 +847,10 @@ def _fill_diff(change: FileChange, old_root: Path, new_root: Path, cfg: DiffConf
     old_text = read_text(old_root / old.path) if old else ""
     new_text = read_text(new_root / new.path) if new else ""
     if old_text is None or new_text is None:
-        change.skipped_reason = "not decodable as text"
+        change.missing = _absent(old_root, old) or _absent(new_root, new)
+        change.skipped_reason = (
+            "missing from the archive" if change.missing else "not decodable as text"
+        )
         return
 
     if old_text and new_text and old_text != new_text:

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/diffing/render_html.py

@@ -482,6 +482,12 @@ def _render_file(change: FileChange, a_root: Path | None = None, b_root: Path |
             # check.
             note += (' Indentation, line endings or blank lines only — '
                      '<code>lw diff --whitespace</code> shows it anyway.')
+        elif change.missing:
+            # The one reason here that is not about the file: nothing is wrong
+            # with it, the archive just does not have it where the index says.
+            note += (' The index lists this file but the version directory does not '
+                     'hold it — <code>lw reindex</code> rebuilds the index from what '
+                     'is on disk.')
         parts.append(f'<div class="note">{note}</div>')
 
     parts.append("</details>")

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/gitmirror.py

@@ -4,8 +4,9 @@ This is the shortest path to a review workflow you already know: every version
 is a commit tagged ``v0007``, so ``git diff v0002 v0010``, ``git log -p``, VS
 Code's diff viewer and any git GUI all work on a single function's history
 without ten unrelated Lambdas mixed into the same repo. It lives at
-``functions/<slug>/repo/``, and ``lambda-watcher open`` hands that folder to an
-editor.
+``repos/<slug>/`` — see :meth:`lambda_watcher.store.Store.repo_dir`, which also
+moves the mirrors older releases kept inside the function directory — and
+``lw open`` hands that folder to an editor.
 """
 
 from __future__ import annotations
@@ -17,7 +18,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from .config import GitMirrorConfig
-from .utils import LOG, matches_any, rmtree
+from .utils import LOG, matches_any, no_window_kwargs, rmtree
 
 
 class GitUnavailable(RuntimeError):
@@ -83,6 +84,7 @@ def _run(repo: Path, *args: str, check: bool = True, env_extra: dict[str, str] |
         text=True,
         env=_git_env(env_extra),
         timeout=300,
+        **no_window_kwargs(),
     )
     if check and proc.returncode != 0:
         raise RuntimeError(f"git {' '.join(args)} failed: {proc.stderr.strip() or proc.stdout.strip()}")

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/notify.py

@@ -6,7 +6,7 @@ import shutil
 import subprocess
 import sys
 
-from .utils import LOG
+from .utils import LOG, no_window_kwargs
 
 
 def notify(title: str, message: str, enabled: bool = True) -> bool:
@@ -37,6 +37,7 @@ def notify(title: str, message: str, enabled: bool = True) -> bool:
                 ["powershell", "-NoProfile", "-NonInteractive", "-Command", ps],
                 capture_output=True,
                 timeout=15,
+                **no_window_kwargs(),
             )
             return True
         if shutil.which("notify-send"):

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/reindex.py

@@ -95,6 +95,10 @@ def _insert(db: Database, store: Store, function_id: int, manifest: dict[str, An
     with no recorded sequence number falls back to the numeric prefix of its
     directory name, which is where the sequence came from in the first place.
     """
+    # back-compat: every section is fetched with a default rather than indexed,
+    # so a manifest written before that section existed rebuilds as a version
+    # missing one facet instead of raising and costing the whole archive its
+    # index. Each analyser added since shipped is one more reason this stays.
     version_meta = manifest.get("version") or {}
     source = manifest.get("source") or {}
     runtime = manifest.get("runtime") or {}
@@ -103,7 +107,10 @@ def _insert(db: Database, store: Store, function_id: int, manifest: dict[str, An
 
     seq = int(version_meta.get("seq") or 0)
     if not seq:
-        # Fall back to the numeric prefix of the directory name.
+        # back-compat: a manifest from before the sequence number was recorded
+        # in it. The number is still in the directory name it was used to build
+        # (`0007-a1b2c3d4`), so recover it there rather than skipping the
+        # version and silently rebuilding a shorter history than the archive has.
         seq = int(version_dir.name.split("-")[0])
 
     with db.transaction():

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/service.py

@@ -30,7 +30,7 @@ from pathlib import Path
 from typing import TypedDict
 
 from .config import Config
-from .utils import LOG
+from .utils import LOG, no_window_kwargs
 
 #: Identifiers registered with the OS. Changing either of these orphans the
 #: service someone already installed, so they are constants, not config.
@@ -120,6 +120,11 @@ def _python_for_service() -> str:
 
     A scheduled task pointed at ``python.exe`` flashes a console window at every
     logon; ``pythonw.exe`` is the same interpreter without one.
+
+    This settles the watcher's own window and nothing else. Having no console is
+    exactly what makes Windows give a *new* one to each ``git`` and
+    ``powershell`` the watcher then spawns, which is
+    :func:`lambda_watcher.utils.no_window_kwargs`' problem.
     """
     executable = Path(sys.executable)
     if sys.platform.startswith("win"):
@@ -157,7 +162,8 @@ def _run(argv: list[str], check: bool = False) -> subprocess.CompletedProcess[st
     LOG.debug("service: %s", " ".join(argv))
     try:
         proc = subprocess.run(
-            argv, capture_output=True, text=True, timeout=_TIMEOUT, check=False
+            argv, capture_output=True, text=True, timeout=_TIMEOUT, check=False,
+            **no_window_kwargs(),
         )
     except FileNotFoundError as exc:
         raise ServiceError(f"{argv[0]} is not installed") from exc
@@ -628,6 +634,9 @@ class _DetachKwargs(TypedDict, total=False):
     annotation. Naming the two keys costs a class and buys a checked call.
 
     ``total=False`` because each platform returns exactly one of them.
+
+    :class:`lambda_watcher.utils.NoWindowKwargs` is the same trick for the
+    keyword that keeps a *captured* child from opening a console window.
     """
 
     creationflags: int

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/store.py

@@ -33,11 +33,41 @@ from .config import Config
 from .utils import LOG, rmtree, short_hash
 
 
-#: Where the mirror used to sit, inside the function directory. Both spellings
-#: are migrated: ``git/`` shipped, ``repo/`` was a brief step on the way here.
+#: back-compat: where the mirror used to sit, inside the function directory.
+#: Both spellings are migrated by :meth:`Store.repo_dir`: ``git/`` shipped,
+#: ``repo/`` was a brief step on the way here. Goes when no archive written
+#: before the move to ``repos/<slug>/`` can still be opened, which for a tool
+#: people leave running unattended is not a date anyone can name.
 LEGACY_REPO_DIRNAMES = ("git", "repo")
 
 
+def posix_stored_dir(stored_dir: str) -> str:
+    """A stored version-directory path with its separators made posix.
+
+    ``functions\\order-processor\\versions\\0001-a1b2c3d4`` →
+    ``functions/order-processor/versions/0001-a1b2c3d4``. Releases before this
+    one built the value with :func:`str` on a :class:`~pathlib.Path`, so an
+    archive first written on Windows holds backslashes — four directories there,
+    one oddly-named file anywhere else. Reading such an archive on Linux or macOS
+    finds no version directory at all, and every file in every diff comes back
+    missing.
+
+    The translation is unambiguous rather than a guess: these paths are built
+    from ``functions/``, a :func:`~lambda_watcher.utils.slugify` output (only
+    ``A-Za-z0-9._-`` survives it), ``versions/`` and
+    :meth:`Store.version_dirname`'s ``NNNN-`` plus hex, so no segment can
+    legitimately contain a backslash. Written by :meth:`Store.relative`, read by
+    :meth:`Store.resolve_version_dir`.
+
+    Goes when no index written by a release that stored the platform's own
+    separator can still be in use — so, in practice, it stays.
+    """
+    # back-compat: an index written on Windows before `Store.relative` wrote
+    # posix. Drop this and such an archive resolves no version at all: the diff
+    # still prints, with no lines in it and every file blamed for its encoding.
+    return stored_dir.replace("\\", "/")
+
+
 @dataclass
 class VersionPaths:
     """The three paths that make up one archived version directory.
@@ -108,6 +138,10 @@ class Store:
         repo = self.cfg.repos_dir / slug
         if repo.exists():
             return repo
+        # back-compat: relocate a mirror an older release left inside the
+        # function directory. Without this the mirror reads as missing, and
+        # `lw open`, `lw git` and `lw diff --mirror` all report there is no
+        # history to show for a function that has one.
         for name in LEGACY_REPO_DIRNAMES:
             legacy = self.function_dir(slug) / name
             if not (legacy / ".git").is_dir():
@@ -136,18 +170,32 @@ class Store:
         return VersionPaths(self.versions_dir(slug) / self.version_dirname(seq, tree_hash))
 
     def resolve_version_dir(self, stored_dir: str) -> Path:
-        """Version dirs are stored relative to the root so the store can move."""
-        path = Path(stored_dir)
+        """Version dirs are stored relative to the root so the store can move.
+
+        Separators are normalised on the way in by :func:`posix_stored_dir`, so
+        an archive an older release wrote on Windows still resolves after it is
+        copied to another machine — without that, every version reads as missing
+        and every file in a diff comes back unreadable.
+        """
+        path = Path(posix_stored_dir(stored_dir))
         return path if path.is_absolute() else self.cfg.root / path
 
     def relative(self, path: Path) -> str:
         """A path rewritten relative to the archive root, for storing and display.
 
+        Posix-separated on every platform — ``functions/order-processor/versions/
+        0001-a1b2c3d4``, never ``functions\\order-processor\\...`` — because this
+        is what goes into ``index.db`` and into ``manifest.json``, and both are
+        meant to survive the archive being copied to another machine. Windows
+        reads a ``/``-separated path perfectly well; Linux and macOS do not read
+        a ``\\``-separated one at all. :func:`posix_stored_dir` translates what
+        earlier releases already wrote.
+
         Falls back to the absolute path when it lies outside the root, which is
         better than raising in the middle of writing a manifest.
         """
         try:
-            return str(path.relative_to(self.cfg.root))
+            return path.relative_to(self.cfg.root).as_posix()
         except ValueError:
             return str(path)
 

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher/utils.py

@@ -7,9 +7,11 @@ import hashlib
 import logging
 import os
 import re
+import subprocess
 import unicodedata
 from datetime import datetime, timezone
 from pathlib import Path, PurePosixPath
+from typing import TypedDict
 
 LOG = logging.getLogger("lambda_watcher")
 
@@ -362,6 +364,50 @@ def rmtree(path: Path) -> None:
         shutil.rmtree(path, onerror=_onerror)
 
 
+class NoWindowKwargs(TypedDict, total=False):
+    """The ``subprocess`` keyword that suppresses a child's console window.
+
+    A ``dict[str, int]`` would say the same thing at runtime and nothing at all
+    to a type checker: splatting one into ``subprocess.run`` makes every keyword
+    it accepts look like it might be receiving an ``int``. Naming the one key
+    costs a class and buys a checked call — the same trade, and the same shape,
+    as :class:`lambda_watcher.service._DetachKwargs`.
+
+    ``total=False`` because every platform but Windows contributes no keys.
+    """
+
+    creationflags: int
+
+
+def no_window_kwargs() -> NoWindowKwargs:
+    """``subprocess`` keywords that stop a child flashing a console window open.
+
+    On Windows a console program inherits its parent's console, and is handed a
+    brand new one when the parent has none. The watcher deliberately has none —
+    ``pythonw.exe``, ``DETACHED_PROCESS``, a hidden scheduled task; see
+    :func:`lambda_watcher.service.watch_argv` — so every ``git`` and
+    ``powershell`` it shells out to during an ingest opens a console window on
+    screen for as long as it runs. Archiving one new version fires five git
+    commands and a notification, so a single downloaded zip reads to the user as
+    a burst of black rectangles flickering over whatever they were doing.
+
+    ``CREATE_NO_WINDOW`` is what suppresses that. Capturing the child's output
+    does not: the console is allocated at process creation whatever the handles
+    later point at, which is why ``capture_output=True`` at every one of those
+    call sites never helped.
+
+    Empty on every other platform, since the flag is Windows-only, so callers
+    splat it unconditionally rather than branching on the platform themselves.
+
+    Only for children whose output is captured. A command that inherits the
+    user's terminal on purpose — :func:`lambda_watcher.gitmirror.passthrough`,
+    which backs ``lw git my-fn log`` — must *not* pass this: no window means no
+    pager and no colour for a command the user typed and is watching.
+    """
+    flag = getattr(subprocess, "CREATE_NO_WINDOW", 0)
+    return {"creationflags": flag} if flag else {}
+
+
 def setup_logging(level: str = "INFO", log_file: Path | None = None) -> logging.Logger:
     """Point the shared ``lambda_watcher`` logger at a level and optional file.
 

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-watcher
-Version: 0.2.0
+Version: 0.2.1
 Summary: Watch your Downloads folder for AWS Lambda deployment zips, archive them as versions, analyse them, and diff any two versions.
 Author: Lambda Watcher contributors
 License: Apache-2.0

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/src/lambda_watcher.egg-info/SOURCES.txt

@@ -46,6 +46,7 @@ tests/test_docs.py
 tests/test_extract.py
 tests/test_identify.py
 tests/test_ingest.py
+tests/test_no_window.py
 tests/test_render_html.py
 tests/test_service.py
 tests/test_utils.py

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/tests/test_cli.py

@@ -547,3 +547,50 @@ def test_commands_leave_no_open_database_handles(archived: Path):
         cli_result = _run(*args)
         assert cli_result.exit_code == 0
         assert not cli._OPEN_DBS, f"`{' '.join(args)}` left the index open"
+
+
+# ------------------------------------------- an archive that came from another machine
+# Everything below is one bug seen from two sides: `versions.dir` used to be stored
+# with the platform's own separator, so an index written on Windows named nothing at
+# all anywhere else. The diff still printed - the index knows which files changed -
+# but with no line in it, and every file labelled as though its bytes were the
+# problem. `lw rename` had the same crack: it patched the stored path as a string
+# and the `functions/<slug>/` it looked for was never there to be replaced.
+def _windowsify(archive: Path) -> list[str]:
+    """Rewrite every stored version dir the way an older release on Windows would."""
+    import sqlite3
+
+    conn = sqlite3.connect(archive / "index.db")
+    with conn:
+        for vid, stored in conn.execute("SELECT id, dir FROM versions").fetchall():
+            conn.execute("UPDATE versions SET dir = ? WHERE id = ?",
+                         (stored.replace("/", "\\"), vid))
+        dirs = [row[0] for row in conn.execute("SELECT dir FROM versions")]
+    conn.close()
+    return dirs
+
+
+def test_an_index_written_on_windows_still_diffs_here(archived: Path):
+    assert all("\\" in d for d in _windowsify(archived))
+    output = _run("diff", "order-processor").output
+    assert "QUEUE_URL" in output                       # the index half, which never broke
+    assert "sqs.send_message" in output                # the line diff, which did
+    assert "missing from the archive" not in output
+
+
+def test_rename_repoints_an_index_written_on_windows(archived: Path):
+    _windowsify(archived)
+    _run("rename", "order-processor", "OrderProcessorProd")
+    assert (archived / "functions" / "OrderProcessorProd").exists()
+    output = _run("diff", "OrderProcessorProd").output
+    assert "sqs.send_message" in output
+    assert "missing from the archive" not in output
+
+
+def test_a_deleted_version_directory_says_what_to_type(archived: Path):
+    """The archive really is incomplete — so say so, and name the command that fixes it."""
+    for version_dir in (archived / "functions" / "order-processor" / "versions").glob("0001-*"):
+        rmtree(version_dir / "code")
+    result = _run("diff", "order-processor")
+    assert "missing from the archive" in result.output
+    assert "lw reindex" in result.output

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/tests/test_diff.py

@@ -706,3 +706,48 @@ def test_the_html_report_shows_the_changed_runs(cfg, db, ingestor: Ingestor, mak
     assert "diffed by word" in html
     assert "lw diff --whitespace" in html          # every note names the way out
     assert '<div class="diff">' not in html        # neither file got a line table
+
+
+# ------------------------------------------- an absent file is not an encoding problem
+# `read_text` answers None both for bytes that are not text and for a file it could
+# not open, and the diff used to call every one of them "not decodable as text". The
+# index is derived from disk, so in practice that message only ever meant the file
+# was gone - and it sent the reader hunting for an encoding that was never wrong.
+def test_a_file_the_archive_no_longer_holds_is_named_missing(cfg, db, ingestor: Ingestor,
+                                                             make_zip):
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V1}))
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V2}))
+
+    store = Store(cfg)
+    first = db.get_version(int(db.get_function("fn")["id"]), 1)
+    (store.resolve_version_dir(first["dir"]) / "code" / "lambda_function.py").unlink()
+
+    change = next(c for c in _diff(cfg, db, ingestor).files if c.path == "lambda_function.py")
+    assert change.missing
+    assert change.skipped_reason == "missing from the archive"
+    assert change.line_count_note == "missing from the archive"
+    assert not change.diff_lines
+
+
+def test_a_readable_file_is_never_reported_as_missing(cfg, db, ingestor: Ingestor, make_zip):
+    """The other half of the pair: a file that is there still diffs as it always did."""
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V1}))
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V2}))
+
+    change = next(c for c in _diff(cfg, db, ingestor).files if c.path == "lambda_function.py")
+    assert not change.missing
+    assert change.skipped_reason is None
+    assert change.diff_lines
+
+
+def test_the_missing_file_is_explained_in_the_html_report(cfg, db, ingestor: Ingestor, make_zip):
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V1}))
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V2}))
+
+    store = Store(cfg)
+    first = db.get_version(int(db.get_function("fn")["id"]), 1)
+    (store.resolve_version_dir(first["dir"]) / "code" / "lambda_function.py").unlink()
+
+    html = render_html(_diff(cfg, db, ingestor))
+    assert "missing from the archive" in html
+    assert "lw reindex" in html

{lambda_watcher-0.2.0 → lambda_watcher-0.2.1}/tests/test_ingest.py

@@ -199,3 +199,33 @@ def test_downloads_at_different_refs_group_into_one_project(ingestor: Ingestor,
     second = ingestor.ingest(make_zip("myrepo-1.3.0.zip", {"myrepo-1.3.0/app.py": PY_V2}))
     assert (first.function_name, first.seq) == ("myrepo", 1)
     assert (second.function_name, second.seq) == ("myrepo", 2)
+
+
+# ------------------------------------------- the index has to outlive the machine
+# `versions.dir` is stored relative to the archive root so the whole archive can be
+# copied elsewhere. That only works if the separator is one every platform reads:
+# Windows resolves `functions/fn/versions/0001-a1b2c3d4` perfectly well, while Linux
+# and macOS read `functions\fn\versions\0001-a1b2c3d4` as one oddly-named file and
+# find no version at all.
+def test_the_stored_version_dir_is_posix_on_every_platform(ingestor: Ingestor, make_zip, db):
+    ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V1}))
+    row = db.list_versions(int(db.get_function("fn")["id"]))[0]
+    assert "\\" not in row["dir"]
+    assert row["dir"].startswith("functions/fn/versions/")
+
+
+def test_a_version_dir_written_on_windows_still_resolves(cfg, db, ingestor: Ingestor, make_zip):
+    """An archive an older release wrote on Windows, opened anywhere else."""
+    from lambda_watcher.store import Store
+
+    result = ingestor.ingest(make_zip("fn.zip", {"lambda_function.py": PY_V1}))
+    row = db.list_versions(int(db.get_function("fn")["id"]))[0]
+    db.conn.execute(
+        "UPDATE versions SET dir = ? WHERE id = ?",
+        (row["dir"].replace("/", "\\"), row["id"]),
+    )
+    reread = db.list_versions(int(db.get_function("fn")["id"]))[0]
+
+    resolved = Store(cfg).resolve_version_dir(reread["dir"])
+    assert resolved == result.version_dir
+    assert (resolved / "code" / "lambda_function.py").is_file()

lambda_watcher-0.2.1/tests/test_no_window.py

@@ -0,0 +1,87 @@
+"""Nothing the background watcher spawns may flash a console window on Windows.
+
+The watcher runs with no console of its own, so Windows hands a brand new one to
+every console program it starts unless ``CREATE_NO_WINDOW`` says otherwise. The
+symptom is only visible on Windows and only while a zip is being archived, so
+these tests fake the flag rather than the platform: that keeps the wiring pinned
+on the Linux leg, where it would otherwise go unchecked until a user complained.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import pytest
+
+from lambda_watcher import gitmirror, notify as notify_mod, service
+from lambda_watcher.utils import no_window_kwargs
+
+WINDOWS_FLAG = 0x08000000
+
+
+@pytest.fixture
+def windows_flag(monkeypatch):
+    """Give this interpreter the flag that only the Windows build defines."""
+    monkeypatch.setattr(subprocess, "CREATE_NO_WINDOW", WINDOWS_FLAG, raising=False)
+    return WINDOWS_FLAG
+
+
+@pytest.fixture
+def recorded(monkeypatch):
+    """Record the keywords of every ``subprocess.run`` and start nothing.
+
+    Every module here does a plain ``import subprocess``, so patching the one
+    module object covers all of them.
+    """
+    calls: list[dict] = []
+
+    def fake_run(argv, **kwargs):
+        """Stand in for a command that succeeded silently."""
+        calls.append(kwargs)
+        return subprocess.CompletedProcess(argv, 0, "", "")
+
+    monkeypatch.setattr(subprocess, "run", fake_run)
+    return calls
+
+
+def test_the_flag_is_only_asked_for_where_it_exists(monkeypatch):
+    monkeypatch.delattr(subprocess, "CREATE_NO_WINDOW", raising=False)
+    assert no_window_kwargs() == {}
+
+
+def test_the_flag_is_passed_through_when_the_platform_has_it(windows_flag):
+    assert no_window_kwargs() == {"creationflags": windows_flag}
+
+
+@pytest.mark.skipif(not sys.platform.startswith("win"), reason="Windows-only flag")
+def test_real_windows_suppresses_the_window():
+    assert no_window_kwargs()["creationflags"] == subprocess.CREATE_NO_WINDOW
+
+
+def test_the_git_mirror_never_opens_a_console(tmp_path, windows_flag, recorded):
+    # Archiving one version runs five of these back to back.
+    gitmirror._run(tmp_path, "status", "--porcelain", check=False)
+    assert recorded[0]["creationflags"] == windows_flag
+
+
+def test_the_toast_notification_never_opens_a_console(
+    monkeypatch, windows_flag, recorded
+):
+    monkeypatch.setattr(sys, "platform", "win32")
+    assert notify_mod.notify("lambda-watcher", "order-processor v3")
+    assert recorded[0]["creationflags"] == windows_flag
+
+
+def test_the_service_manager_never_opens_a_console(windows_flag, recorded):
+    service._run(["schtasks", "/Query", "/TN", "lambda-watcher"])
+    assert recorded[0]["creationflags"] == windows_flag
+
+
+def test_the_interactive_git_passthrough_keeps_its_terminal(
+    tmp_path, windows_flag, recorded
+):
+    # `lw git my-fn log` is watched by the person who typed it: suppressing the
+    # window would take the pager and the colour with it.
+    gitmirror.passthrough(tmp_path, ["log", "--oneline"])
+    assert "creationflags" not in recorded[0]