wehub-resource-sync
437 lines
14 KiB
Python
437 lines
14 KiB
Python
"""Tests for the ``@``-mention file completer and extraction helpers.
|
|
|
|
Covers trigger detection, fuzzy matching, recursive file scanning,
|
|
attachment extraction, and text stripping — all using temporary
|
|
directories so no real filesystem state leaks.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import pathlib
|
|
|
|
from omnigent_ui_sdk.terminal._completer import (
|
|
FileMentionCompleter,
|
|
_find_at_mention,
|
|
_fuzzy_score,
|
|
_is_hidden,
|
|
_list_files,
|
|
_walk_files,
|
|
extract_at_mentions,
|
|
strip_at_mentions,
|
|
)
|
|
from omnigent_ui_sdk.terminal._host import PendingAttachment
|
|
from prompt_toolkit.completion import CompleteEvent
|
|
from prompt_toolkit.document import Document
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _find_at_mention
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_find_at_mention_start_of_line():
|
|
"""Bare ``@query`` at position 0 triggers."""
|
|
result = _find_at_mention("@host")
|
|
assert result is not None
|
|
query, start = result
|
|
assert query == "host"
|
|
assert start == -5 # len("@host")
|
|
|
|
|
|
def test_find_at_mention_mid_line():
|
|
"""``@`` preceded by a space triggers."""
|
|
result = _find_at_mention("check @main")
|
|
assert result is not None
|
|
query, start = result
|
|
assert query == "main"
|
|
assert start == -5
|
|
|
|
|
|
def test_find_at_mention_bare_at():
|
|
"""Bare ``@`` with no query text triggers (lists all files)."""
|
|
result = _find_at_mention("look @")
|
|
assert result is not None
|
|
query, start = result
|
|
assert query == ""
|
|
assert start == -1
|
|
|
|
|
|
def test_find_at_mention_email_no_trigger():
|
|
"""``@`` inside a word (email) does NOT trigger."""
|
|
assert _find_at_mention("user@domain.com") is None
|
|
|
|
|
|
def test_find_at_mention_no_at():
|
|
"""No ``@`` at all returns ``None``."""
|
|
assert _find_at_mention("plain text") is None
|
|
|
|
|
|
def test_find_at_mention_at_with_space_after():
|
|
"""``@`` followed by whitespace does NOT trigger (query has spaces)."""
|
|
assert _find_at_mention("@ foo") is None
|
|
|
|
|
|
def test_find_at_mention_start_bare():
|
|
"""Bare ``@`` at start of line triggers."""
|
|
result = _find_at_mention("@")
|
|
assert result is not None
|
|
query, start = result
|
|
assert query == ""
|
|
assert start == -1
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _fuzzy_score
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_fuzzy_score_exact_prefix():
|
|
"""Exact prefix match returns a positive score."""
|
|
score = _fuzzy_score("host", "_host.py")
|
|
assert score is not None
|
|
assert score > 0
|
|
|
|
|
|
def test_fuzzy_score_scattered_chars():
|
|
"""Characters scattered across candidate still match."""
|
|
score = _fuzzy_score("hp", "_host.py")
|
|
assert score is not None
|
|
assert score > 0
|
|
|
|
|
|
def test_fuzzy_score_no_match():
|
|
"""Non-matching query returns ``None``."""
|
|
assert _fuzzy_score("xyz", "_host.py") is None
|
|
|
|
|
|
def test_fuzzy_score_empty_query():
|
|
"""Empty query matches everything with score 0."""
|
|
assert _fuzzy_score("", "anything.py") == 0
|
|
|
|
|
|
def test_fuzzy_score_case_insensitive():
|
|
"""Matching is case-insensitive."""
|
|
score = _fuzzy_score("HOST", "_host.py")
|
|
assert score is not None
|
|
assert score > 0
|
|
|
|
|
|
def test_fuzzy_score_consecutive_beats_scattered():
|
|
"""Consecutive character matches score higher than scattered ones."""
|
|
consecutive = _fuzzy_score("main", "main.py")
|
|
scattered = _fuzzy_score("main", "m_a_i_n.py")
|
|
assert consecutive is not None
|
|
assert scattered is not None
|
|
assert consecutive > scattered
|
|
|
|
|
|
def test_fuzzy_score_boundary_bonus():
|
|
"""Matching at word boundaries (after ``/``, ``_``, ``.``) scores higher."""
|
|
# "mp" in "main.py" hits the 'm' at pos 0 (boundary) and 'p' after '.'
|
|
boundary = _fuzzy_score("mp", "main.py")
|
|
# "mp" in "lamp.txt" — 'm' is mid-word, 'p' is consecutive but not boundary
|
|
mid_word = _fuzzy_score("mp", "lamp.txt")
|
|
assert boundary is not None
|
|
assert mid_word is not None
|
|
assert boundary > mid_word
|
|
|
|
|
|
def test_fuzzy_score_case_exact_bonus():
|
|
"""Exact-case match gets a small bonus over case-insensitive match."""
|
|
exact = _fuzzy_score("Host", "Host.py")
|
|
inexact = _fuzzy_score("host", "Host.py")
|
|
assert exact is not None
|
|
assert inexact is not None
|
|
assert exact > inexact
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _walk_files
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_walk_files_basic(tmp_path: pathlib.Path):
|
|
"""Direct children are returned."""
|
|
(tmp_path / "main.py").touch()
|
|
(tmp_path / "readme.md").touch()
|
|
files = _walk_files(str(tmp_path))
|
|
assert sorted(files) == ["main.py", "readme.md"]
|
|
|
|
|
|
def test_walk_files_subdirectory(tmp_path: pathlib.Path):
|
|
"""Files in subdirectories include the relative path."""
|
|
sub = tmp_path / "src"
|
|
sub.mkdir()
|
|
(sub / "utils.py").touch()
|
|
files = _walk_files(str(tmp_path))
|
|
assert "src/utils.py" in files
|
|
|
|
|
|
def test_walk_files_hidden_excluded(tmp_path: pathlib.Path):
|
|
"""Hidden files and directories are excluded."""
|
|
(tmp_path / ".hidden_file").touch()
|
|
hidden_dir = tmp_path / ".git"
|
|
hidden_dir.mkdir()
|
|
(hidden_dir / "config").touch()
|
|
(tmp_path / "visible.py").touch()
|
|
files = _walk_files(str(tmp_path))
|
|
assert files == ["visible.py"]
|
|
|
|
|
|
def test_walk_files_deep_nesting(tmp_path: pathlib.Path):
|
|
"""Deeply nested files are included (no depth limit)."""
|
|
deep = tmp_path / "a" / "b" / "c" / "d"
|
|
deep.mkdir(parents=True)
|
|
(deep / "deep.py").touch()
|
|
files = _walk_files(str(tmp_path))
|
|
assert "a/b/c/d/deep.py" in files
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _is_hidden
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_is_hidden_dotfile():
|
|
"""A path with a dot-prefixed component is hidden."""
|
|
assert _is_hidden(".git/config") is True
|
|
assert _is_hidden("src/.env") is True
|
|
|
|
|
|
def test_is_hidden_normal():
|
|
"""A path with no dot-prefixed components is not hidden."""
|
|
assert _is_hidden("src/main.py") is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _list_files (git ls-files integration)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_list_files_respects_gitignore(tmp_path: pathlib.Path):
|
|
"""Files matched by ``.gitignore`` are excluded from git-based listing."""
|
|
import subprocess
|
|
|
|
subprocess.run(["git", "init"], cwd=tmp_path, capture_output=True, check=True)
|
|
subprocess.run(
|
|
["git", "config", "user.email", "test@test.com"],
|
|
cwd=tmp_path,
|
|
capture_output=True,
|
|
check=True,
|
|
)
|
|
subprocess.run(
|
|
["git", "config", "user.name", "Test"],
|
|
cwd=tmp_path,
|
|
capture_output=True,
|
|
check=True,
|
|
)
|
|
(tmp_path / ".gitignore").write_text("build/\n*.log\n")
|
|
(tmp_path / "main.py").touch()
|
|
build_dir = tmp_path / "build"
|
|
build_dir.mkdir()
|
|
(build_dir / "output.js").touch()
|
|
(tmp_path / "debug.log").touch()
|
|
# Stage tracked files so git ls-files --cached returns them.
|
|
subprocess.run(
|
|
["git", "add", "main.py", ".gitignore"],
|
|
cwd=tmp_path,
|
|
capture_output=True,
|
|
check=True,
|
|
)
|
|
files = _list_files(str(tmp_path))
|
|
assert "main.py" in files
|
|
assert "build/output.js" not in files
|
|
assert "debug.log" not in files
|
|
|
|
|
|
def test_list_files_falls_back_to_walk(tmp_path: pathlib.Path):
|
|
"""Non-git directories fall back to ``_walk_files``."""
|
|
(tmp_path / "hello.py").touch()
|
|
# tmp_path is not a git repo, so _list_files should fall back.
|
|
files = _list_files(str(tmp_path))
|
|
assert "hello.py" in files
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# FileMentionCompleter.get_completions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _completions_for(text: str, cwd: str) -> list[str]:
|
|
"""Helper: run the completer and return display texts as plain strings."""
|
|
completer = FileMentionCompleter(cwd=cwd)
|
|
doc = Document(text, cursor_position=len(text))
|
|
event = CompleteEvent(text_inserted=False, completion_requested=False)
|
|
results: list[str] = []
|
|
for c in completer.get_completions(doc, event):
|
|
# ``Completion.display`` may be ``FormattedText`` or ``str``.
|
|
display = c.display
|
|
if isinstance(display, str):
|
|
results.append(display)
|
|
else:
|
|
# FormattedText is a list of (style, text) tuples.
|
|
results.append("".join(t for _, t in display))
|
|
return results
|
|
|
|
|
|
def test_completer_exact_prefix(tmp_path: pathlib.Path):
|
|
"""Prefix query returns matching files."""
|
|
(tmp_path / "main.py").touch()
|
|
(tmp_path / "readme.md").touch()
|
|
results = _completions_for("@main", str(tmp_path))
|
|
assert "main.py" in results
|
|
# "readme.md" does not match "main" as fuzzy (r doesn't precede m)
|
|
# but actually "main" in "readme" won't match because 'a' comes
|
|
# before 'i' — let's just check main.py is there
|
|
assert "main.py" in results
|
|
|
|
|
|
def test_completer_fuzzy_match(tmp_path: pathlib.Path):
|
|
"""Fuzzy query ``hostp`` matches ``_host.py``."""
|
|
(tmp_path / "_host.py").touch()
|
|
results = _completions_for("@hostp", str(tmp_path))
|
|
assert "_host.py" in results
|
|
|
|
|
|
def test_completer_bare_at_lists_all(tmp_path: pathlib.Path):
|
|
"""Bare ``@`` lists all files."""
|
|
(tmp_path / "a.py").touch()
|
|
(tmp_path / "b.txt").touch()
|
|
results = _completions_for("@", str(tmp_path))
|
|
assert sorted(results) == ["a.py", "b.txt"]
|
|
|
|
|
|
def test_completer_no_match(tmp_path: pathlib.Path):
|
|
"""Query with no matches yields nothing."""
|
|
(tmp_path / "main.py").touch()
|
|
results = _completions_for("@zzz", str(tmp_path))
|
|
assert results == []
|
|
|
|
|
|
def test_completer_email_no_trigger(tmp_path: pathlib.Path):
|
|
"""Email-like text does not trigger completions."""
|
|
(tmp_path / "main.py").touch()
|
|
results = _completions_for("user@main", str(tmp_path))
|
|
assert results == []
|
|
|
|
|
|
def test_completer_subdirectory_files(tmp_path: pathlib.Path):
|
|
"""Files in subdirectories are listed with relative paths."""
|
|
sub = tmp_path / "src"
|
|
sub.mkdir()
|
|
(sub / "app.py").touch()
|
|
results = _completions_for("@src", str(tmp_path))
|
|
assert "src/app.py" in results
|
|
|
|
|
|
def test_completer_inserts_at_prefix(tmp_path: pathlib.Path):
|
|
"""Completion text includes the ``@`` prefix."""
|
|
(tmp_path / "main.py").touch()
|
|
completer = FileMentionCompleter(cwd=str(tmp_path))
|
|
doc = Document("@main", cursor_position=5)
|
|
event = CompleteEvent(text_inserted=False, completion_requested=False)
|
|
completions = list(completer.get_completions(doc, event))
|
|
assert any(c.text == "@main.py" for c in completions)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# extract_at_mentions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_extract_existing_file(tmp_path: pathlib.Path):
|
|
"""``@filename`` for an existing file returns a PendingAttachment."""
|
|
(tmp_path / "data.csv").touch()
|
|
result = extract_at_mentions("check @data.csv", cwd=str(tmp_path))
|
|
assert len(result) == 1
|
|
assert result[0].path == str((tmp_path / "data.csv").resolve())
|
|
assert result[0].is_image is False
|
|
|
|
|
|
def test_extract_nonexistent_file(tmp_path: pathlib.Path):
|
|
"""``@filename`` for a nonexistent file returns empty list."""
|
|
result = extract_at_mentions("check @missing.txt", cwd=str(tmp_path))
|
|
assert result == []
|
|
|
|
|
|
def test_extract_image_detection(tmp_path: pathlib.Path):
|
|
"""Image files are detected via extension."""
|
|
(tmp_path / "screenshot.png").touch()
|
|
result = extract_at_mentions("look @screenshot.png", cwd=str(tmp_path))
|
|
assert len(result) == 1
|
|
assert result[0].is_image is True
|
|
|
|
|
|
def test_extract_subdirectory(tmp_path: pathlib.Path):
|
|
"""Relative paths in subdirectories resolve correctly."""
|
|
sub = tmp_path / "src"
|
|
sub.mkdir()
|
|
(sub / "main.py").touch()
|
|
result = extract_at_mentions("@src/main.py", cwd=str(tmp_path))
|
|
assert len(result) == 1
|
|
assert result[0].path == str((sub / "main.py").resolve())
|
|
|
|
|
|
def test_extract_bare_at_ignored():
|
|
"""Bare ``@`` without a filename produces no attachments."""
|
|
result = extract_at_mentions("@ something")
|
|
assert result == []
|
|
|
|
|
|
def test_extract_multiple_mentions(tmp_path: pathlib.Path):
|
|
"""Multiple ``@filename`` tokens in one line all resolve."""
|
|
(tmp_path / "a.py").touch()
|
|
(tmp_path / "b.py").touch()
|
|
result = extract_at_mentions("@a.py and @b.py", cwd=str(tmp_path))
|
|
assert len(result) == 2
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# strip_at_mentions
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_strip_removes_resolved_tokens(tmp_path: pathlib.Path):
|
|
"""Resolved ``@filename`` tokens are removed from display text."""
|
|
(tmp_path / "data.csv").touch()
|
|
attachments = [
|
|
PendingAttachment(
|
|
path=str((tmp_path / "data.csv").resolve()),
|
|
is_image=False,
|
|
)
|
|
]
|
|
old_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(tmp_path)
|
|
result = strip_at_mentions("check @data.csv for bugs", attachments)
|
|
finally:
|
|
os.chdir(old_cwd)
|
|
assert "@data.csv" not in result
|
|
assert "data.csv" not in result
|
|
assert "check" in result
|
|
assert "bugs" in result
|
|
|
|
|
|
def test_strip_preserves_non_at_tokens(tmp_path: pathlib.Path):
|
|
"""Non-``@`` tokens are preserved."""
|
|
attachments: list[PendingAttachment] = []
|
|
old_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(tmp_path)
|
|
result = strip_at_mentions("hello world", attachments)
|
|
finally:
|
|
os.chdir(old_cwd)
|
|
assert result == "hello world"
|
|
|
|
|
|
def test_strip_preserves_unresolved_at_tokens(tmp_path: pathlib.Path):
|
|
"""``@filename`` tokens not in attachments are preserved."""
|
|
attachments: list[PendingAttachment] = []
|
|
old_cwd = os.getcwd()
|
|
try:
|
|
os.chdir(tmp_path)
|
|
result = strip_at_mentions("check @missing.txt", attachments)
|
|
finally:
|
|
os.chdir(old_cwd)
|
|
assert "@missing.txt" in result
|