Make streaming and git handler tests pass on Windows

Both suites failed only on the Windows CI, for reasons in the tests
rather than the code under test.

- Command runner streaming tests wrote through text-mode stdout/stderr,
  where Windows translates `\n` to `\r\n`. A literal `\r\n` therefore
  became `\r\r\n` and the buffered/CRLF assertions saw different bytes.
  Write bytes via `sys.stdout.buffer` / `sys.stderr.buffer` instead so
  the child emits exactly what the test asserts on.
- fine_git handler tests used a POSIX literal `/repo` as the fake
  toplevel. It has no drive on Windows, so it is not absolute and
  cannot become a `file://` URI. Add a `repo_root` fixture backed by
  `tmp_path` and a `toplevel_result` helper that prints it with forward
  slashes, as Git for Windows does, and derive expected URIs from it.

Author: Aksem

finecode_extension_runner/tests/test_command_runner_streaming.py

@@ -135,7 +135,13 @@ async def test_subscribing_late_replays_what_was_already_produced() -> None:
 async def test_buffered_output_is_unchanged_for_callers_that_never_subscribe() -> None:
     """The path every existing handler uses, including the trailing newline."""
     process = await _runner().run(
-        _python("import sys\nprint('out')\nsys.stderr.write('err\\n')")
+        _python(
+            "import sys\n"
+            "sys.stdout.buffer.write(b'out\\n')\n"
+            "sys.stdout.buffer.flush()\n"
+            "sys.stderr.buffer.write(b'err\\n')\n"
+            "sys.stderr.buffer.flush()\n"
+        )
     )
     await process.wait_for_end()
 
@@ -233,8 +239,8 @@ async def test_stderr_is_complete_when_a_stdout_failure_surfaces() -> None:
             "import sys\n"
             f"sys.stdout.write('x' * {oversized})\n"
             "sys.stdout.flush()\n"
-            "sys.stderr.write('the real error message\\n')\n"
-            "sys.stderr.flush()\n"
+            "sys.stderr.buffer.write(b'the real error message\\n')\n"
+            "sys.stderr.buffer.flush()\n"
         )
     )
 
@@ -366,10 +372,13 @@ async def test_a_trailing_carriage_return_without_a_newline_is_data() -> None:
 
 
 async def test_crlf_line_endings_are_still_stripped() -> None:
-    """The `\\r` that does precede a `\\n` is part of the terminator."""
+    """The `\\r` that does precede a `\\n` is part of the terminator. It writes
+    bytes because a text-mode stdout on Windows would turn the literal `\\r\\n`
+    into `\\r\\r\\n`."""
     process = await _runner().run(
         _python(
-            "import sys\nsys.stdout.write('one\\r\\ntwo\\r\\n')\nsys.stdout.flush()"
+            "import sys\nsys.stdout.buffer.write(b'one\\r\\ntwo\\r\\n')\n"
+            "sys.stdout.buffer.flush()"
         )
     )
 

presets/fine_git/tests/conftest.py

@@ -4,6 +4,7 @@
 from collections.abc import AsyncIterator
 from pathlib import Path
 
+import pytest
 from finecode_extension_api.interfaces import icommandrunner
 
 
@@ -57,3 +58,21 @@ async def run(
         icommandrunner.check_argv(cmd)
         self.commands.append(list(cmd))
         return self._results.pop(0)
+
+
+@pytest.fixture
+def repo_root(tmp_path: Path) -> Path:
+    """A repository toplevel that is absolute on every OS.
+
+    A POSIX literal such as ``/repo`` has no drive on Windows, so it is not
+    absolute there and cannot become a ``file://`` URI.
+    """
+    return tmp_path
+
+
+def toplevel_result(repo_root: Path) -> FakeCommandResult:
+    """``git rev-parse --show-toplevel`` output for *repo_root*.
+
+    Git prints forward slashes on every OS, Git for Windows included.
+    """
+    return FakeCommandResult(exit_code=0, stdout=f"{repo_root.as_posix()}\n")

presets/fine_git/tests/test_get_git_diff_handler.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 
 import pytest
-from conftest import FakeCommandResult, FakeCommandRunner
+from conftest import FakeCommandResult, FakeCommandRunner, toplevel_result
 from finecode_extension_api.interfaces.icommandrunner import ICommandRunner
 from finecode_extension_runner.testing import run_handler
 
@@ -43,14 +43,16 @@
 
 
 @pytest.mark.asyncio
-async def test_two_file_diff_parses_change_kind_and_added_removed_lines() -> None:
+async def test_two_file_diff_parses_change_kind_and_added_removed_lines(
+    repo_root: Path,
+) -> None:
     """A modified file and an added file must each decode to the right
     change_kind, with added_lines/removed_lines stripped of their +/- markers
     and the +++/--- header lines excluded, while patch keeps the diff --git
     header verbatim."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=_MODIFIED_SECTION + _ADDED_SECTION),
         ]
     )
@@ -67,27 +69,29 @@ async def test_two_file_diff_parses_change_kind_and_added_removed_lines() -> Non
 
     modified, added = result.files
 
-    assert modified.path == "file:///repo/mod.txt"
+    assert modified.path == (repo_root / "mod.txt").as_uri()
     assert modified.change_kind == GitChangeKind.MODIFIED
     assert modified.added_lines == ["new line"]
     assert modified.removed_lines == ["old line"]
     assert modified.patch.startswith("diff --git a/mod.txt b/mod.txt\n")
     assert modified.is_binary is False
 
-    assert added.path == "file:///repo/new.txt"
+    assert added.path == (repo_root / "new.txt").as_uri()
     assert added.change_kind == GitChangeKind.ADDED
     assert added.added_lines == ["new content"]
     assert added.removed_lines == []
 
 
 @pytest.mark.asyncio
-async def test_binary_diff_section_is_reported_without_added_removed_lines() -> None:
+async def test_binary_diff_section_is_reported_without_added_removed_lines(
+    repo_root: Path,
+) -> None:
     """A `Binary files ... differ` section carries no hunks to scan for +/-
     lines, so it must set is_binary and leave added/removed lines empty
     rather than the parser tripping over the absence of a `@@` marker."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=_BINARY_SECTION),
         ]
     )
@@ -107,13 +111,15 @@ async def test_binary_diff_section_is_reported_without_added_removed_lines() ->
 
 
 @pytest.mark.asyncio
-async def test_staged_source_and_context_lines_reach_the_diff_command() -> None:
+async def test_staged_source_and_context_lines_reach_the_diff_command(
+    repo_root: Path,
+) -> None:
     """`source=STAGED` must add `--cached` and `context_lines=0` must add
     `-U0` to the `git diff` invocation, or a caller's request is silently
     ignored."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=""),
         ]
     )
@@ -133,14 +139,15 @@ async def test_staged_source_and_context_lines_reach_the_diff_command() -> None:
 @pytest.mark.asyncio
 async def test_paths_none_scopes_diff_to_the_project_directory(
     tmp_path: Path,
+    repo_root: Path,
 ) -> None:
     """`paths=None` means the project directory, not the repository. `git diff`
     ignores cwd and covers the whole repository unless a pathspec says otherwise,
     so the handler must name the project directory itself -- without it, a nested
     project's diff would include every other project in the same repository."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=""),
         ]
     )
@@ -176,7 +183,9 @@ async def test_paths_none_scopes_diff_to_the_project_directory(
 
 
 @pytest.mark.asyncio
-async def test_content_lines_starting_with_dashes_or_pluses_are_not_dropped() -> None:
+async def test_content_lines_starting_with_dashes_or_pluses_are_not_dropped(
+    repo_root: Path,
+) -> None:
     """Inside a hunk, a removed `---` arrives as `----` and an added `+++more` as
     `++++more` (verified against real git). Excluding those prefixes as if they
     were file headers loses real content, and `added_lines`/`removed_lines` then
@@ -185,7 +194,7 @@ async def test_content_lines_starting_with_dashes_or_pluses_are_not_dropped() ->
     corner one."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=_MARKDOWN_RULE_SECTION),
         ]
     )
@@ -203,13 +212,15 @@ async def test_content_lines_starting_with_dashes_or_pluses_are_not_dropped() ->
 
 
 @pytest.mark.asyncio
-async def test_section_naming_no_path_is_skipped_not_fatal_for_the_whole_diff() -> None:
+async def test_section_naming_no_path_is_skipped_not_fatal_for_the_whole_diff(
+    repo_root: Path,
+) -> None:
     """A mode-only change on a path git had to quote carries no `---`/`+++` lines
     and a header the parser cannot match (real git output). One unparseable
     section must cost that one file, not the whole answer."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(
                 exit_code=0,
                 stdout=_MODE_CHANGE_QUOTED_PATH_SECTION + _MODIFIED_SECTION,
@@ -225,4 +236,4 @@ async def test_section_naming_no_path_is_skipped_not_fatal_for_the_whole_diff()
     )
 
     assert result.error is None
-    assert [file.path for file in result.files] == ["file:///repo/mod.txt"]
+    assert [file.path for file in result.files] == [(repo_root / "mod.txt").as_uri()]

presets/fine_git/tests/test_get_git_status_handler.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 
 import pytest
-from conftest import FakeCommandResult, FakeCommandRunner
+from conftest import FakeCommandResult, FakeCommandRunner, toplevel_result
 from finecode_extension_api.interfaces.icommandrunner import ICommandRunner
 from finecode_extension_runner.testing import run_handler
 
@@ -13,7 +13,9 @@
 
 
 @pytest.mark.asyncio
-async def test_porcelain_output_is_parsed_including_the_two_record_rename() -> None:
+async def test_porcelain_output_is_parsed_including_the_two_record_rename(
+    repo_root: Path,
+) -> None:
     """A modified file, a staged-and-modified file, an untracked file, and a rename
     (whose original path arrives as a second, unprefixed -z record) must all decode
     to the right FileStatus -- the rename encoding is the easy part to get wrong."""
@@ -27,7 +29,7 @@ async def test_porcelain_output_is_parsed_including_the_two_record_rename() -> N
     status_stdout = "\0".join(records) + "\0"
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=status_stdout),
         ]
     )
@@ -39,31 +41,31 @@ async def test_porcelain_output_is_parsed_including_the_two_record_rename() -> N
         service_overrides={ICommandRunner: command_runner},
     )
 
-    assert result.repo_root == "file:///repo"
+    assert result.repo_root == repo_root.as_uri()
     assert result.error is None
     assert len(result.changes) == 4
 
     modified, staged_and_modified, untracked, renamed = result.changes
 
-    assert modified.path == "file:///repo/modified.txt"
+    assert modified.path == (repo_root / "modified.txt").as_uri()
     assert modified.index_status == GitChangeKind.UNMODIFIED
     assert modified.worktree_status == GitChangeKind.MODIFIED
     assert modified.original_path is None
 
-    assert staged_and_modified.path == "file:///repo/staged_and_modified.txt"
+    assert staged_and_modified.path == (repo_root / "staged_and_modified.txt").as_uri()
     assert staged_and_modified.index_status == GitChangeKind.MODIFIED
     assert staged_and_modified.worktree_status == GitChangeKind.MODIFIED
     assert staged_and_modified.original_path is None
 
-    assert untracked.path == "file:///repo/untracked.txt"
+    assert untracked.path == (repo_root / "untracked.txt").as_uri()
     assert untracked.index_status == GitChangeKind.UNTRACKED
     assert untracked.worktree_status == GitChangeKind.UNTRACKED
     assert untracked.original_path is None
 
-    assert renamed.path == "file:///repo/new_name.txt"
+    assert renamed.path == (repo_root / "new_name.txt").as_uri()
     assert renamed.index_status == GitChangeKind.RENAMED
     assert renamed.worktree_status == GitChangeKind.UNMODIFIED
-    assert renamed.original_path == "file:///repo/old_name.txt"
+    assert renamed.original_path == (repo_root / "old_name.txt").as_uri()
 
 
 @pytest.mark.asyncio
@@ -88,12 +90,12 @@ async def test_not_a_git_repository_is_a_result_state_not_an_error() -> None:
 
 
 @pytest.mark.asyncio
-async def test_empty_paths_list_skips_status_but_still_reports_repo_root() -> None:
+async def test_empty_paths_list_skips_status_but_still_reports_repo_root(
+    repo_root: Path,
+) -> None:
     """`paths=[]` means nothing was requested -- the handler reports the repo root
     it already resolved without spending a `git status` call on an empty request."""
-    command_runner = FakeCommandRunner(
-        results=[FakeCommandResult(exit_code=0, stdout="/repo\n")]
-    )
+    command_runner = FakeCommandRunner(results=[toplevel_result(repo_root)])
 
     result = await run_handler(
         GitGetGitStatusHandler,
@@ -102,23 +104,23 @@ async def test_empty_paths_list_skips_status_but_still_reports_repo_root() -> No
         service_overrides={ICommandRunner: command_runner},
     )
 
-    assert result.repo_root == "file:///repo"
+    assert result.repo_root == repo_root.as_uri()
     assert result.changes == []
     assert len(command_runner.commands) == 1
 
 
 @pytest.mark.asyncio
-async def test_include_ignored_without_untracked_asks_git_for_both_and_filters() -> (
-    None
-):
+async def test_include_ignored_without_untracked_asks_git_for_both_and_filters(
+    repo_root: Path,
+) -> None:
     """`include_ignored=True` with `include_untracked=False` is not expressible as
     git flags: `-uno --ignored=matching` is `fatal: Unsupported combination of
     ignored and untracked-files arguments`, and `-uno --ignored=traditional`
     reports no ignored files at all. The handler therefore asks with `-uall` and
     drops the untracked entries itself."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(
                 exit_code=0, stdout="!! build.log\0?? scratch.txt\0 M tracked.py\0"
             ),
@@ -138,18 +140,20 @@ async def test_include_ignored_without_untracked_asks_git_for_both_and_filters()
     assert "-uno" not in status_cmd
 
     assert [change.path for change in result.changes] == [
-        "file:///repo/build.log",
-        "file:///repo/tracked.py",
+        (repo_root / "build.log").as_uri(),
+        (repo_root / "tracked.py").as_uri(),
     ]
 
 
 @pytest.mark.asyncio
-async def test_excluding_untracked_alone_still_asks_git_to_suppress_them() -> None:
+async def test_excluding_untracked_alone_still_asks_git_to_suppress_them(
+    repo_root: Path,
+) -> None:
     """Without `include_ignored` there is nothing to widen for, so the cheaper
     `-uno` is used and git never enumerates untracked files."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=""),
         ]
     )
@@ -169,14 +173,15 @@ async def test_excluding_untracked_alone_still_asks_git_to_suppress_them() -> No
 @pytest.mark.asyncio
 async def test_paths_none_scopes_status_to_the_project_directory(
     tmp_path: Path,
+    repo_root: Path,
 ) -> None:
     """`paths=None` means the project directory, not the repository. `git status`
     ignores cwd and reports the whole repository unless a pathspec says otherwise,
     so the handler must name the project directory itself -- without it, a nested
     project's status would include every other project in the same repository."""
     command_runner = FakeCommandRunner(
         results=[
-            FakeCommandResult(exit_code=0, stdout="/repo\n"),
+            toplevel_result(repo_root),
             FakeCommandResult(exit_code=0, stdout=""),
         ]
     )