wehub-resource-sync
268 lines
10 KiB
Python
268 lines
10 KiB
Python
"""Tests for GitStore — line_ages() and core git operations."""
|
|
|
|
import subprocess
|
|
from datetime import datetime, timedelta, timezone
|
|
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from nanobot.utils.gitstore import GitStore
|
|
|
|
|
|
@pytest.fixture
|
|
def git(tmp_path):
|
|
"""Create an initialized GitStore with tracked MEMORY.md."""
|
|
g = GitStore(tmp_path, tracked_files=["MEMORY.md", "SOUL.md"])
|
|
g.init()
|
|
return g
|
|
|
|
|
|
class TestLineAges:
|
|
def test_returns_empty_when_not_initialized(self, tmp_path):
|
|
"""line_ages should return [] if the git repo is not initialized."""
|
|
git = GitStore(tmp_path, tracked_files=["MEMORY.md"])
|
|
assert git.line_ages("MEMORY.md") == []
|
|
|
|
def test_returns_empty_for_missing_file(self, git):
|
|
"""line_ages should return [] for a file that doesn't exist."""
|
|
assert git.line_ages("SOUL.md") == []
|
|
|
|
def test_returns_empty_for_empty_file(self, git, tmp_path):
|
|
"""line_ages should return [] for an empty tracked file."""
|
|
(tmp_path / "SOUL.md").write_text("", encoding="utf-8")
|
|
git.auto_commit("empty soul")
|
|
assert git.line_ages("SOUL.md") == []
|
|
|
|
def test_one_age_per_line(self, git, tmp_path):
|
|
"""line_ages should return one entry per line in the file."""
|
|
content = "# Memory\n\n## Section A\n- item 1\n"
|
|
(tmp_path / "MEMORY.md").write_text(content, encoding="utf-8")
|
|
git.auto_commit("initial")
|
|
ages = git.line_ages("MEMORY.md")
|
|
assert len(ages) == len(content.splitlines())
|
|
|
|
def test_fresh_lines_have_age_zero(self, git, tmp_path):
|
|
"""Lines committed today should have age_days=0."""
|
|
(tmp_path / "MEMORY.md").write_text("## A\n- x\n", encoding="utf-8")
|
|
git.auto_commit("initial")
|
|
ages = git.line_ages("MEMORY.md")
|
|
assert all(a.age_days == 0 for a in ages)
|
|
|
|
def test_age_differentiates_across_days(self, git, tmp_path):
|
|
"""Lines committed today should show correct age when 'now' is mocked forward."""
|
|
(tmp_path / "MEMORY.md").write_text("## A\n- x\n", encoding="utf-8")
|
|
git.auto_commit("initial")
|
|
|
|
future_now = datetime.now(tz=timezone.utc) + timedelta(days=30)
|
|
with patch("nanobot.utils.gitstore.datetime") as mock_dt:
|
|
mock_dt.now.return_value = future_now
|
|
mock_dt.fromtimestamp = datetime.fromtimestamp
|
|
ages = git.line_ages("MEMORY.md")
|
|
|
|
assert len(ages) == 2
|
|
assert all(a.age_days == 30 for a in ages)
|
|
|
|
def test_annotate_failure_returns_empty(self, tmp_path):
|
|
"""If annotate fails, line_ages should return [] gracefully."""
|
|
git = GitStore(tmp_path, tracked_files=["MEMORY.md"])
|
|
# Don't init — annotate will fail
|
|
assert git.line_ages("MEMORY.md") == []
|
|
|
|
def test_partial_edit_only_updates_changed_lines(self, git, tmp_path):
|
|
"""Only modified lines should reflect the new commit's timestamp."""
|
|
now = datetime(2026, 5, 1, tzinfo=timezone.utc)
|
|
old = now - timedelta(days=30)
|
|
|
|
(tmp_path / "MEMORY.md").write_text(
|
|
"# Memory\n\n## A\n- old\n\n## B\n- keep\n", encoding="utf-8"
|
|
)
|
|
with patch("dulwich.worktree.time.time", return_value=old.timestamp()):
|
|
git.auto_commit("commit1")
|
|
|
|
# Only modify section A
|
|
(tmp_path / "MEMORY.md").write_text(
|
|
"# Memory\n\n## A\n- new\n\n## B\n- keep\n", encoding="utf-8"
|
|
)
|
|
with patch("dulwich.worktree.time.time", return_value=now.timestamp()):
|
|
git.auto_commit("commit2")
|
|
|
|
with patch("nanobot.utils.gitstore.datetime") as mock_dt:
|
|
mock_dt.now.return_value = now
|
|
mock_dt.fromtimestamp = datetime.fromtimestamp
|
|
ages = git.line_ages("MEMORY.md")
|
|
|
|
lines = (tmp_path / "MEMORY.md").read_text(encoding="utf-8").splitlines()
|
|
assert len(ages) == len(lines)
|
|
age_by_line = {line: age.age_days for line, age in zip(lines, ages, strict=True)}
|
|
assert age_by_line["- new"] == 0
|
|
assert age_by_line["- keep"] == 30
|
|
|
|
|
|
class TestSummarizeWorkingTree:
|
|
"""Ground-truth diff summary used to keep Dream audit records honest."""
|
|
|
|
def test_empty_when_not_initialized(self, tmp_path):
|
|
git = GitStore(tmp_path, tracked_files=["MEMORY.md"])
|
|
assert git.summarize_working_tree(["MEMORY.md"]) == ""
|
|
|
|
def test_empty_when_no_changes(self, git):
|
|
assert git.summarize_working_tree(["MEMORY.md", "SOUL.md"]) == ""
|
|
|
|
def test_summarizes_real_change(self, git, tmp_path):
|
|
(tmp_path / "MEMORY.md").write_text("# Memory\n- new fact\n", encoding="utf-8")
|
|
summary = git.summarize_working_tree(["MEMORY.md"])
|
|
assert "MEMORY.md: +2 -0" in summary
|
|
assert "new fact" in summary
|
|
assert "1 file changed, 2 insertions(+), 0 deletions(-)" in summary
|
|
|
|
def test_only_reports_requested_paths(self, git, tmp_path):
|
|
# MEMORY.md changes, but we only ask about the unchanged SOUL.md.
|
|
(tmp_path / "MEMORY.md").write_text("changed\n", encoding="utf-8")
|
|
assert git.summarize_working_tree(["SOUL.md"]) == ""
|
|
|
|
def test_counts_additions_and_removals(self, git, tmp_path):
|
|
(tmp_path / "MEMORY.md").write_text("# M\n- keep\n- new\n", encoding="utf-8")
|
|
summary = git.summarize_working_tree(["MEMORY.md"])
|
|
assert "MEMORY.md: +3 -0" in summary
|
|
|
|
def test_detects_deletion(self, git, tmp_path):
|
|
# File removed from the working tree (must have content first; the
|
|
# fixture's tracked files start empty, so an empty-file delete is a no-op).
|
|
(tmp_path / "MEMORY.md").write_text("has content\n", encoding="utf-8")
|
|
git.auto_commit("add content")
|
|
(tmp_path / "MEMORY.md").unlink()
|
|
summary = git.summarize_working_tree(["MEMORY.md"])
|
|
assert summary # a removal is still a change
|
|
assert "deletion" in summary
|
|
|
|
def test_non_utf8_file_marked_binary_without_replacement_chars(self, git, tmp_path):
|
|
# Invalid UTF-8 must not leak replacement chars into the audit record.
|
|
(tmp_path / "MEMORY.md").write_bytes(b"\x89PNG\r\n\x1a\n\xff\xfe\x00\x01")
|
|
summary = git.summarize_working_tree(["MEMORY.md"])
|
|
assert "MEMORY.md: binary or non-UTF-8 file changed" in summary
|
|
assert "\ufffd" not in summary # no U+FFFD replacement chars leaked
|
|
|
|
|
|
class TestNestedRepoProtection:
|
|
"""Regression tests for GitHub issue #2980: nested repo protection."""
|
|
|
|
def test_init_refuses_inside_git_repo(self, tmp_path):
|
|
"""init() should detect it's inside an existing git repo and refuse."""
|
|
project = tmp_path / "project"
|
|
project.mkdir()
|
|
(project / ".git").mkdir()
|
|
|
|
workspace = project / "workspace"
|
|
workspace.mkdir()
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is False
|
|
assert not (workspace / ".git").is_dir()
|
|
|
|
def test_init_preserves_existing_gitignore(self, tmp_path):
|
|
"""init() should preserve existing .gitignore entries and append new ones."""
|
|
workspace = tmp_path / "workspace"
|
|
workspace.mkdir()
|
|
|
|
existing = "*.pyc\n__pycache__/\n"
|
|
(workspace / ".gitignore").write_text(existing, encoding="utf-8")
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is True
|
|
gitignore = (workspace / ".gitignore").read_text(encoding="utf-8")
|
|
assert "*.pyc" in gitignore
|
|
assert "__pycache__/" in gitignore
|
|
assert "!MEMORY.md" in gitignore
|
|
assert "!.gitignore" in gitignore
|
|
|
|
def test_init_no_gitignore_creates_new(self, tmp_path):
|
|
"""init() should create .gitignore with Dream content when none exists."""
|
|
workspace = tmp_path / "workspace"
|
|
workspace.mkdir()
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is True
|
|
gitignore = (workspace / ".gitignore").read_text(encoding="utf-8")
|
|
expected = g._build_gitignore()
|
|
assert gitignore == expected
|
|
|
|
def test_init_gitignore_merge_idempotent(self, tmp_path):
|
|
"""init() should not duplicate Dream entries already in .gitignore."""
|
|
workspace = tmp_path / "workspace"
|
|
workspace.mkdir()
|
|
|
|
# Pre-existing .gitignore that already has some Dream entries
|
|
existing = "*.pyc\n/*\n!MEMORY.md\n"
|
|
(workspace / ".gitignore").write_text(existing, encoding="utf-8")
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is True
|
|
gitignore = (workspace / ".gitignore").read_text(encoding="utf-8")
|
|
# No duplicate lines
|
|
lines = gitignore.splitlines()
|
|
assert lines.count("/*") == 1
|
|
assert lines.count("!MEMORY.md") == 1
|
|
# Existing entry preserved, new Dream entries appended
|
|
assert "*.pyc" in gitignore
|
|
assert "!.gitignore" in gitignore
|
|
|
|
def test_init_outside_git_repo_works_normally(self, tmp_path):
|
|
"""init() should succeed and create .git when not inside a git repo."""
|
|
workspace = tmp_path / "workspace"
|
|
workspace.mkdir()
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is True
|
|
assert (workspace / ".git").is_dir()
|
|
|
|
def test_init_refuses_inside_git_worktree(self, tmp_path):
|
|
"""init() should refuse when the parent checkout is a git worktree."""
|
|
repo = tmp_path / "repo"
|
|
repo.mkdir()
|
|
subprocess.run(["git", "init", "-q", str(repo)], check=True)
|
|
(repo / "README.md").write_text("x\n", encoding="utf-8")
|
|
subprocess.run(["git", "-C", str(repo), "add", "README.md"], check=True)
|
|
subprocess.run(
|
|
[
|
|
"git",
|
|
"-C",
|
|
str(repo),
|
|
"-c",
|
|
"user.name=test",
|
|
"-c",
|
|
"user.email=test@example.com",
|
|
"commit",
|
|
"-q",
|
|
"-m",
|
|
"init",
|
|
],
|
|
check=True,
|
|
)
|
|
subprocess.run(["git", "-C", str(repo), "branch", "wt-branch"], check=True)
|
|
|
|
worktree = tmp_path / "worktree"
|
|
subprocess.run(
|
|
["git", "-C", str(repo), "worktree", "add", "-q", str(worktree), "wt-branch"],
|
|
check=True,
|
|
)
|
|
assert (worktree / ".git").is_file()
|
|
|
|
workspace = worktree / "workspace"
|
|
workspace.mkdir()
|
|
|
|
g = GitStore(workspace, tracked_files=["MEMORY.md"])
|
|
result = g.init()
|
|
|
|
assert result is False
|
|
assert not (workspace / ".git").exists()
|