blot-git 0.3.1__tar.gz → 0.4.0__tar.gz

blot_git-0.4.0/.github/workflows/blot.yml

@@ -0,0 +1,14 @@
+name: Blot on Blot
+
+# Runs this repo's own action (action.yml) on every pull request, installing Blot from the
+# pull request's code: it tests the action end to end and reviews Blot's history with Blot.
+on: pull_request
+
+jobs:
+  blot:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./
+        with:
+          blot-package: .

{blot_git-0.3.1 → blot_git-0.4.0}/.pre-commit-hooks.yaml

@@ -1,11 +1,14 @@
 # Lets users of the pre-commit framework add blot with:
 #   - repo: https://github.com/Sym-jay/Blot
-#     rev: v0.1.0
+#     rev: v0.4.0
 #     hooks: [{id: blot}]
+# The first commit indexes the repo's history; later commits refresh the index incrementally.
 - id: blot
   name: blot (history-aware checks)
   entry: blot check --staged
   language: python
   pass_filenames: false
   always_run: true
+  # blot warns without failing the commit, and pre-commit hides output of passing hooks
+  verbose: true
   stages: [pre-commit]

{blot_git-0.3.1 → blot_git-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: blot-git
-Version: 0.3.1
+Version: 0.4.0
 Summary: A pre-commit check that has read your project's history: warns when a change removes a fix, re-adds a fixed bug, or forgets a file that always changes too.
 Project-URL: Homepage, https://github.com/Sym-jay/Blot
 Project-URL: Issues, https://github.com/Sym-jay/Blot/issues
@@ -40,7 +40,7 @@ It runs locally, needs no account or AI, and stays quiet unless the history give
 ```bash
 pip install blot-git
 cd your-repo
-blot index           # one-time, builds .git/blot.db
+blot index           # optional: the first check indexes history itself
 blot install-hook    # adds Blot to your pre-commit hook
 blot why src/app.py:42   # which commit explains this line, skipping refactors
 blot index --github  # optional: issue/PR titles and labels via the gh CLI

{blot_git-0.3.1 → blot_git-0.4.0}/README.md

@@ -49,7 +49,7 @@ Sora comes in four warm palettes:
 ```bash
 pip install blot-git  # the PyPI name is blot-git; the command is just `blot`
 cd your-repo
-blot index            # one-time, builds .git/blot.db (refreshes incrementally after that)
+blot index            # optional: the first check builds .git/blot.db itself and keeps it current
 blot install-hook     # adds Blot to .git/hooks/pre-commit without touching existing hooks
 ```
 
@@ -79,6 +79,27 @@ blot index --github
 
 With the [GitHub CLI](https://cli.github.com) logged in, Blot fetches the titles and labels of the issues and PRs your fix commits mention, so warnings read `fixes #2935 "copy_current_request_context copies old session object"` (a real Flask issue) instead of a bare number. A `bug` label makes a commit count as a load-bearing fix; a fix-looking commit whose issues are only labelled `enhancement` or `documentation` is demoted. Refreshes only fetch what's new. Repos with GitHub Issues turned off (they track bugs elsewhere) are skipped.
 
+## Use in CI
+
+Run Blot on every pull request and see its findings as warnings on the changed lines:
+
+```yaml
+# .github/workflows/blot.yml
+name: Blot
+on: pull_request
+jobs:
+  blot:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: Sym-jay/Blot@v0.4.0
+```
+
+The action checks out the pull request with its full history, installs Blot, runs `blot index` and
+`blot check --range origin/<base>..HEAD --format json`, and turns each finding into a warning annotation.
+It never fails the job because of findings. Inputs: `blot-package` (what to `pip install`; default
+`blot-git`, the latest PyPI release), `python-version` (default `3.13`) and `base-ref`
+(default: the pull request's base branch).
+
 ## Measure it on your repo
 
 ```bash

blot_git-0.4.0/action.yml

@@ -0,0 +1,73 @@
+# Run Blot on a pull request and show its findings as warning annotations.
+# Usage (in a workflow triggered by pull_request):
+#   - uses: Sym-jay/Blot@v0.4.0
+# See "Use in CI" in README.md.
+name: Blot
+description: History-aware checks on the commits of a pull request, shown as warning annotations
+author: Sym-jay
+branding:
+  icon: alert-triangle
+  color: orange
+
+inputs:
+  base-ref:
+    description: Branch the pull request merges into; the action checks origin/<base-ref>..HEAD
+    default: ${{ github.base_ref }}
+  python-version:
+    description: Python version used to run Blot
+    default: "3.13"
+  blot-package:
+    description: What to pip install (a pip requirement, e.g. blot-git==0.3.2)
+    default: blot-git  # the latest release on PyPI
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Blot reads the whole history
+
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - name: Install Blot
+      shell: bash
+      env:
+        BLOT_PACKAGE: ${{ inputs.blot-package }}
+      run: python -m pip install --disable-pip-version-check "$BLOT_PACKAGE"
+
+    - name: Run Blot
+      shell: bash
+      env:
+        BASE_REF: ${{ inputs.base-ref }}
+        BLOT_FINDINGS: ${{ runner.temp }}/blot-findings.json
+        PYTHONUTF8: "1"  # commit subjects in findings may not be ASCII
+      run: |
+        if [[ -z "$BASE_REF" ]]; then
+          echo "::error title=blot::No base branch: run this action on pull_request, or set base-ref"
+          exit 1
+        fi
+        blot index
+        blot check --range "origin/${BASE_REF}..HEAD" --format json > "$BLOT_FINDINGS"
+        python - <<'PY'
+        # Turn blot's JSON findings into workflow annotations (::warning file=...,line=...::message).
+        import json, os
+
+        def esc(text, prop=False):
+            text = text.replace("%", "%25").replace("\r", "%0D").replace("\n", "%0A")
+            return text.replace(":", "%3A").replace(",", "%2C") if prop else text
+
+        with open(os.environ["BLOT_FINDINGS"], encoding="utf-8") as f:
+            raw = f.read()
+        # blot check prints nothing on stdout when it hits an internal error (the reason is in the log above)
+        findings = json.loads(raw) if raw.strip() else []
+        for f in findings:
+            props = f"file={esc(f['path'], True)}"
+            if f.get("line"):
+                props += f",line={f['line']}"
+            props += f",title={esc('blot: ' + f['check'], True)}"
+            message = "\n".join([f["message"], *f.get("evidence", [])])
+            print(f"::warning {props}::{esc(message)}")
+        print(f"blot: {len(findings)} finding{'' if len(findings) == 1 else 's'}")
+        PY

{blot_git-0.3.1 → blot_git-0.4.0}/docs/PYPI.md

@@ -15,7 +15,7 @@ It runs locally, needs no account or AI, and stays quiet unless the history give
 ```bash
 pip install blot-git
 cd your-repo
-blot index           # one-time, builds .git/blot.db
+blot index           # optional: the first check indexes history itself
 blot install-hook    # adds Blot to your pre-commit hook
 blot why src/app.py:42   # which commit explains this line, skipping refactors
 blot index --github  # optional: issue/PR titles and labels via the gh CLI

{blot_git-0.3.1 → blot_git-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blot-git"
-version = "0.3.1"
+version = "0.4.0"
 description = "A pre-commit check that has read your project's history: warns when a change removes a fix, re-adds a fixed bug, or forgets a file that always changes too."
 readme = "docs/PYPI.md"  # text-only; the GitHub README's relative Sora images break on PyPI
 license = { text = "MIT" }

{blot_git-0.3.1 → blot_git-0.4.0}/src/blot/__init__.py

@@ -1,3 +1,3 @@
 """blot: history-aware pre-commit checks."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"

{blot_git-0.3.1 → blot_git-0.4.0}/src/blot/cli.py

@@ -11,6 +11,7 @@ Commands:
 from __future__ import annotations
 
 import argparse
+import os
 import sys
 
 from blot import __version__
@@ -42,18 +43,31 @@ def _cmd_index(args: argparse.Namespace) -> int:
     return 0
 
 
-def _cmd_check(args: argparse.Namespace) -> int:
-    from blot.diff import read_changes
+def _open_index(repo: str):
+    """Open the index, building or refreshing it first.
+
+    The pre-commit framework installs Blot where users can't easily run `blot index`, so the hook
+    must look after the index itself: one full build on first use, then cheap incremental refreshes.
+    """
+    from blot.index import build_index
     from blot.store import Store
 
+    if not os.path.exists(Store.db_path(repo)):
+        print("blot: first run, indexing this repo's history once (big repos can take a minute)...",
+              file=sys.stderr)
+    build_index(repo)
+    return Store.open(repo)
+
+
+def _cmd_check(args: argparse.Namespace) -> int:
+    from blot.diff import range_base, read_changes
+
     try:
         config = load_config(args.repo)
-        store = Store.open(args.repo)
-        if store is None:
-            # Never break a commit because the index is missing; just say how to fix it.
-            print("blot: no index yet, run `blot index` (commit allowed)", file=sys.stderr)
-            return 0
+        store = _open_index(args.repo)
         changes = read_changes(args.repo, rev_range=args.range)
+        if args.range:  # removed lines are numbered as in the range's base, not as in HEAD
+            store.rev = range_base(args.repo, args.range)
         findings = [f for check in all_checks(config) for f in check.run(changes, store, config)]
     except Exception as exc:  # Blot's own failures must never block a commit
         print(f"blot: internal error, skipping checks ({exc.__class__.__name__}: {exc})", file=sys.stderr)
@@ -63,13 +77,9 @@ def _cmd_check(args: argparse.Namespace) -> int:
 
 
 def _cmd_why(args: argparse.Namespace) -> int:
-    from blot.store import Store
     from blot.why import WhyError, explain, render
 
-    store = Store.open(args.repo)
-    if store is None:
-        print("blot: no index yet, run `blot index` first", file=sys.stderr)
-        return 1
+    store = _open_index(args.repo)
     try:
         path, explained = explain(store, args.location, args.rev)
     except WhyError as exc:
@@ -90,7 +100,7 @@ def _cmd_install_hook(args: argparse.Namespace) -> int:
     status = hooks.install(args.repo)
     print(f"blot: pre-commit hook {status} ({hooks.hook_path(args.repo)})")
     if status != "already installed":
-        print("blot: run `blot index` once so the checks have history to work with")
+        print("blot: the first commit indexes this repo's history (or run `blot index` now)")
     return 0
 
 

{blot_git-0.3.1 → blot_git-0.4.0}/src/blot/diff.py

@@ -145,3 +145,13 @@ def read_changes(repo: str, rev_range: str | None = None) -> list[FileChange]:
     args = ["diff", "-U0", "--no-color", "--no-ext-diff", "-M"]
     args.append(rev_range if rev_range else "--cached")
     return parse_unified_diff(run_git(repo, *args))
+
+
+def range_base(repo: str, rev_range: str) -> str:
+    """The commit `git diff <rev_range>` compares against: A for `A..B`, the merge base for `A...B`."""
+    if "..." in rev_range:
+        left, right = rev_range.split("...", 1)
+        return run_git(repo, "merge-base", left or "HEAD", right or "HEAD").strip()
+    if ".." in rev_range:
+        return rev_range.split("..", 1)[0] or "HEAD"
+    return rev_range

{blot_git-0.3.1 → blot_git-0.4.0}/src/blot/git.py

@@ -34,6 +34,46 @@ def git_dir(repo: str) -> str:
     return run_git(repo, "rev-parse", "--absolute-git-dir").strip()
 
 
+def head_sha(repo: str) -> str | None:
+    """The commit HEAD points at, read from .git files (the hook calls this on every commit).
+
+    Handles loose and packed refs, detached HEAD and worktrees (`commondir`). Anything else, such as
+    the reftable format, falls back to `git rev-parse`.
+    """
+    gd = git_dir(repo)
+    try:
+        with open(os.path.join(gd, "HEAD"), encoding="utf-8") as f:
+            head = f.read().strip()
+        if not head.startswith("ref: "):
+            return head if len(head) == 40 else None
+        ref = head[5:]
+        bases = [gd]
+        common = os.path.join(gd, "commondir")
+        if os.path.isfile(common):
+            with open(common, encoding="utf-8") as f:
+                bases.append(os.path.normpath(os.path.join(gd, f.read().strip())))
+        for base in bases:
+            loose = os.path.join(base, *ref.split("/"))
+            if os.path.isfile(loose):
+                with open(loose, encoding="utf-8") as f:
+                    return f.read().strip()
+            packed = os.path.join(base, "packed-refs")
+            if os.path.isfile(packed):
+                with open(packed, encoding="utf-8") as f:
+                    for line in f:
+                        sha, _, name = line.strip().partition(" ")
+                        if name == ref:
+                            return sha
+        if not os.path.isdir(os.path.join(gd, "reftable")):
+            return None  # unborn branch: no commits yet
+    except OSError:
+        pass
+    try:
+        return run_git(repo, "rev-parse", "--verify", "-q", "HEAD").strip() or None
+    except subprocess.CalledProcessError:
+        return None
+
+
 def run_git(repo: str, *args: str) -> str:
     result = subprocess.run(
         ["git", "-C", repo, *args],

{blot_git-0.3.1 → blot_git-0.4.0}/src/blot/index.py

@@ -20,7 +20,7 @@ from dataclasses import dataclass
 from blot.classify import CommitInfo, fix_severity, is_refactor, linked_issues
 from blot.config import Config, load_config
 from blot.diff import is_trivial_line, line_hash, normalize_line, parse_unified_diff
-from blot.git import run_git
+from blot.git import head_sha, run_git
 from blot.store import CommitRow, Store
 
 _RECORD, _FIELD = "\x1e", "\x1f"
@@ -144,13 +144,15 @@ def build_index(
 ) -> IndexResult:
     """Index history up to `upto` into `db_path` (default .git/blot.db). Bench replays use both."""
     start = time.perf_counter()
-    config = config or load_config(repo)
-    head = _head(repo, upto)
+    head = head_sha(repo) if upto == "HEAD" else _head(repo, upto)
 
     store = Store.open(repo, db_path)
     last = store.get_meta("last_sha") if store else None
     if store:
         store.close()
+    if not full and head is not None and last == head:  # already current: `blot check` hits this on every commit
+        return IndexResult(0, 0, time.perf_counter() - start, False)
+    config = config or load_config(repo)
     rebuild = full or not last or (head is not None and not _is_ancestor(repo, last, head))
     store = Store.create(repo, fresh=rebuild, path=db_path)
 

blot_git-0.4.0/tests/test_action.py

@@ -0,0 +1,67 @@
+"""action.yml: the step that turns `blot check --format json` output into workflow annotations."""
+
+import json
+import os
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+from blot.cli import main
+
+ACTION = Path(__file__).resolve().parent.parent / "action.yml"
+
+
+def _annotate_script() -> str:
+    """The Python heredoc in action.yml's "Run Blot" step (stdlib only, so no YAML parser needed)."""
+    lines = ACTION.read_text(encoding="utf-8").splitlines()
+    start = next(i for i, line in enumerate(lines) if line.strip() == "python - <<'PY'") + 1
+    end = next(i for i in range(start, len(lines)) if lines[i].strip() == "PY")
+    return textwrap.dedent("\n".join(lines[start:end])) + "\n"
+
+
+def _annotate(tmp_path: Path, raw: str) -> list[str]:
+    findings = tmp_path / "findings.json"
+    findings.write_text(raw, encoding="utf-8")
+    out = subprocess.run([sys.executable, "-c", _annotate_script()], env={**os.environ, "BLOT_FINDINGS": str(findings)},
+                         capture_output=True, text=True, check=True).stdout
+    return out.splitlines()
+
+
+def test_findings_become_warning_annotations(tmp_path):
+    findings = [
+        {"check": "removed-fix", "path": "src/a,b.py", "line": 12, "severity": 2,
+         "message": "You're changing a line added by a bug fix: 100% sure.",
+         "evidence": ['8efea0cc "Break reference cycle" (2020-10-03, fixes #3761)']},
+        {"check": "forgot-related-file", "path": "app.py", "line": None, "severity": 1,
+         "message": "app.py usually changes with views.py.", "evidence": []},
+    ]
+    assert _annotate(tmp_path, json.dumps(findings)) == [
+        "::warning file=src/a%2Cb.py,line=12,title=blot%3A removed-fix::"
+        "You're changing a line added by a bug fix: 100%25 sure."
+        '%0A8efea0cc "Break reference cycle" (2020-10-03, fixes #3761)',
+        "::warning file=app.py,title=blot%3A forgot-related-file::app.py usually changes with views.py.",
+        "blot: 2 findings",
+    ]
+
+
+def test_no_findings_and_no_output(tmp_path):
+    assert _annotate(tmp_path, "[]\n") == ["blot: 0 findings"]
+    assert _annotate(tmp_path, "") == ["blot: 0 findings"]  # blot check hit an internal error
+
+
+def test_range_check_of_a_pr_branch_is_annotated(make_repo, tmp_path, capsys):
+    from test_checks import AFTER, BEFORE, GUARD
+
+    repo = make_repo([("Add app", {"app.py": BEFORE}),
+                      ("Break reference cycle in App (fixes #3761)", {"app.py": AFTER})])
+    git = lambda *args: subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)  # noqa: E731
+    git("switch", "-q", "-c", "pr")
+    (repo / "app.py").write_text(AFTER.replace(GUARD, "self_ref = self"), encoding="utf-8")
+    git("commit", "-q", "-am", "Simplify App")
+
+    assert main(["--repo", str(repo), "check", "--range", "main..HEAD", "--format", "json"]) == 0
+    lines = _annotate(tmp_path, capsys.readouterr().out)
+    assert lines[-1].startswith("blot: ") and lines[-1] != "blot: 0 findings"
+    assert any(line.startswith("::warning file=app.py,line=") and ",title=blot%3A removed-fix::" in line
+               for line in lines)

{blot_git-0.3.1 → blot_git-0.4.0}/tests/test_cli.py

@@ -11,10 +11,26 @@ def test_registry_has_three_checks():
     assert [c.id for c in REGISTRY] == ["removed-fix", "readded-bug", "forgot-related-file"]
 
 
-def test_check_without_index_never_blocks(make_repo, capsys):
+def test_check_builds_the_index_on_first_run_then_refreshes_it(make_repo, capsys):
+    import subprocess
+
+    from test_checks import AFTER, BEFORE, GUARD
+
     repo = make_repo([("feat: init", {"a.py": "x = 1\n"})])
     assert main(["--repo", str(repo), "check"]) == 0
-    assert "run `blot index`" in capsys.readouterr().err
+    assert "first run, indexing" in capsys.readouterr().err
+    assert main(["--repo", str(repo), "check"]) == 0
+    assert capsys.readouterr().err == ""  # already indexed: silent
+
+    # a fix committed after the first check must be known to the next one (incremental refresh)
+    for message, content in (("Add app", BEFORE), ("Break reference cycle in App (fixes #3761)", AFTER)):
+        (repo / "app.py").write_text(content, encoding="utf-8")
+        subprocess.run(["git", "-C", str(repo), "add", "-A"], check=True)
+        subprocess.run(["git", "-C", str(repo), "commit", "-q", "-m", message], check=True)
+    (repo / "app.py").write_text(AFTER.replace(GUARD, "self_ref = self"), encoding="utf-8")
+    subprocess.run(["git", "-C", str(repo), "add", "-A"], check=True)
+    assert main(["--repo", str(repo), "check"]) == 0
+    assert "removed-fix" in capsys.readouterr().out
 
 
 def test_render_text():
@@ -62,3 +78,25 @@ def test_removed_fix_traces_past_refactor(make_repo, capsys):
     # plain blame stops at the split; blot must cite the fix behind it
     assert finding["evidence"][0].startswith(sha("HEAD~1")[:7] + ' "Break reference cycle in App (fixes #3761)"')
     assert finding["evidence"][1].startswith("traced past refactor " + sha("HEAD")[:7])
+
+
+def test_check_range_reads_removed_lines_at_the_base(make_repo, capsys):
+    """In CI the PR's commits are already in the index and HEAD no longer has the removed line."""
+    from test_checks import AFTER, BEFORE, GUARD
+
+    repo = make_repo([("Add app", {"app.py": BEFORE}),
+                      ("Break reference cycle in App (fixes #3761)", {"app.py": AFTER})])
+    git = lambda *args: subprocess.run(["git", "-C", str(repo), *args], check=True, capture_output=True)  # noqa: E731
+    git("switch", "-q", "-c", "pr")
+    (repo / "app.py").write_text(AFTER.replace(GUARD, "self_ref = self"), encoding="utf-8")
+    git("commit", "-q", "-am", "Simplify App")
+    git("switch", "-q", "main")
+    (repo / "README.md").write_text("app\n", encoding="utf-8")
+    git("add", "README.md")
+    git("commit", "-q", "-m", "docs: readme")  # main moves on, so A..B and A...B differ
+    git("switch", "-q", "pr")
+
+    for rev_range in ("HEAD~1..HEAD", "main...pr"):
+        assert main(["--repo", str(repo), "check", "--range", rev_range, "--format", "json"]) == 0
+        found = [(f["check"], f["path"], f["line"]) for f in json.loads(capsys.readouterr().out)]
+        assert ("removed-fix", "app.py", 3) in found, rev_range

blot_git-0.4.0/tests/test_git.py

@@ -0,0 +1,36 @@
+import os
+import subprocess
+
+from blot.git import git_dir, head_sha, run_git
+
+
+def test_head_sha_matches_git_in_every_ref_layout(make_repo, tmp_path, monkeypatch):
+    monkeypatch.delenv("GIT_DIR", raising=False)
+    repo = make_repo([("one", {"a.py": "x = 1\n"}), ("two", {"a.py": "x = 2\n"})])
+    rev = lambda path: run_git(str(path), "rev-parse", "HEAD").strip()  # noqa: E731
+
+    assert head_sha(str(repo)) == rev(repo)  # loose ref
+    run_git(str(repo), "pack-refs", "--all")
+    assert head_sha(str(repo)) == rev(repo)  # packed-refs only
+    wt = tmp_path / "wt"
+    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", "-b", "side", str(wt)], check=True)
+    assert head_sha(str(wt)) == rev(wt)  # worktree: ref lives in the common dir
+    run_git(str(repo), "checkout", "-q", "--detach", "HEAD~1")
+    assert head_sha(str(repo)) == rev(repo)  # detached HEAD
+    empty = tmp_path / "empty"
+    subprocess.run(["git", "init", "-q", str(empty)], check=True)
+    assert head_sha(str(empty)) is None  # no commits yet
+
+
+def test_git_dir_matches_git_from_root_subdir_and_worktree(make_repo, tmp_path, monkeypatch):
+    monkeypatch.delenv("GIT_DIR", raising=False)
+    repo = make_repo([("init", {"pkg/a.py": "x = 1\n"})])
+    expected = os.path.normcase(os.path.normpath(run_git(str(repo), "rev-parse", "--absolute-git-dir").strip()))
+
+    assert os.path.normcase(git_dir(str(repo))) == expected
+    assert os.path.normcase(git_dir(str(repo / "pkg"))) == expected
+
+    wt = tmp_path / "wt"
+    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", str(wt)], check=True)
+    wt_expected = os.path.normcase(os.path.normpath(run_git(str(wt), "rev-parse", "--absolute-git-dir").strip()))
+    assert os.path.normcase(git_dir(str(wt))) == wt_expected

{blot_git-0.3.1 → blot_git-0.4.0}/tests/test_hooks.py

@@ -43,7 +43,7 @@ def test_real_commit_runs_hook_and_is_not_blocked(make_repo):
     subprocess.run(["git", "-C", str(repo), "add", "a.py"], check=True)
     done = subprocess.run(["git", "-C", str(repo), "commit", "-m", "change"], capture_output=True, text=True)
     assert done.returncode == 0
-    assert "no index yet" in done.stderr  # the hook really ran
+    assert "first run, indexing" in done.stderr  # the hook really ran, and indexed the repo
 
 
 def test_uninstall_deletes_hook_blot_created(make_repo):

{blot_git-0.3.1 → blot_git-0.4.0}/tests/test_why_github.py

@@ -46,9 +46,8 @@ def test_why_traces_past_a_refactor(make_repo):
 
 def test_why_cli_and_errors(make_repo, capsys):
     repo = make_repo(history())
-    assert main(["--repo", str(repo), "why", "core.py:1"]) == 1  # no index yet
-    assert "run `blot index`" in capsys.readouterr().err
-    main(["--repo", str(repo), "index", "--quiet"])
+    assert main(["--repo", str(repo), "why", "core.py:1"]) == 0  # builds the index itself
+    assert "first run, indexing" in capsys.readouterr().err
     assert main(["--repo", str(repo), "why", "missing.py:1"]) == 1
     assert "not tracked" in capsys.readouterr().err
     assert main(["--repo", str(repo), "why", "core.py:999"]) == 1

blot_git-0.3.1/tests/test_git.py

@@ -1,18 +0,0 @@
-import os
-import subprocess
-
-from blot.git import git_dir, run_git
-
-
-def test_git_dir_matches_git_from_root_subdir_and_worktree(make_repo, tmp_path, monkeypatch):
-    monkeypatch.delenv("GIT_DIR", raising=False)
-    repo = make_repo([("init", {"pkg/a.py": "x = 1\n"})])
-    expected = os.path.normcase(os.path.normpath(run_git(str(repo), "rev-parse", "--absolute-git-dir").strip()))
-
-    assert os.path.normcase(git_dir(str(repo))) == expected
-    assert os.path.normcase(git_dir(str(repo / "pkg"))) == expected
-
-    wt = tmp_path / "wt"
-    subprocess.run(["git", "-C", str(repo), "worktree", "add", "-q", str(wt)], check=True)
-    wt_expected = os.path.normcase(os.path.normpath(run_git(str(wt), "rev-parse", "--absolute-git-dir").strip()))
-    assert os.path.normcase(git_dir(str(wt))) == wt_expected