| #!/usr/bin/env python3 | |
| # -*- coding: utf-8 -*- | |
| # SPDX-License-Identifier: GPL-2.0-or-later | |
| # Copyright (C) 2026 by the Linux Foundation | |
| # | |
| """Tests for the editor integration files under ``misc/vim`` and ``misc/emacs``. | |
| The vim ftplugin and the emacs major mode reimplement the *same* review-reply | |
| behaviour twice -- hunk trimming, skip-marker coalescing and "adopt comment" -- | |
| and all of it rides on a format contract with the Python code that generates the | |
| buffer (:func:`b4.review._review._render_quoted_diff_with_comments`). Two | |
| things can quietly break: the Python side could emit a line shape the plugins do | |
| not recognise, or the two plugins could drift apart from each other. | |
| This module guards both, in two layers: | |
| 1. **Format-contract tests** (pure Python, no editors). They assert that a | |
| generated review buffer only uses the line prefixes the plugins know about, | |
| that the skip markers the plugins insert stay invisible to b4's parser, and | |
| that both plugins write the marker with one identical template. | |
| 2. **Behavioural tests** that drive the *real* vim and emacs over a shared set | |
| of fixtures and check both produce the expected buffer -- so the two ports | |
| cannot diverge. vim is driven through keystroke replay (``-s``) with a full | |
| editor, because its auto-marker hangs off the ``TextChanged`` autocommand, | |
| which does not fire in silent-ex (``-es``) mode; emacs runs ``-batch`` with a | |
| generated driver script. Each editor is skipped individually when its binary | |
| is not installed, so a minimal CI box still passes. | |
| """ | |
| import pathlib | |
| import shutil | |
| import subprocess | |
| from typing import Dict, List, NamedTuple | |
| import pytest | |
| from b4.review._review import ( | |
| _extract_editor_comments, | |
| _render_quoted_diff_with_comments, | |
| ) | |
| # -------------------------------------------------------------------------- | |
| # Locations of the plugin files under test. | |
| # -------------------------------------------------------------------------- | |
| _MISC = pathlib.Path(__file__).resolve().parents[2] / 'misc' | |
| _VIM_RTP = _MISC / 'vim' | |
| _VIM_FTPLUGIN = _VIM_RTP / 'ftplugin' / 'b4review.vim' | |
| _EL_MODE = _MISC / 'emacs' / 'b4-review-mode.el' | |
| # The single template both plugins use to write a skip marker. The behavioural | |
| # tests confirm both also *recognise* it; this constant pins the spelling. | |
| _MARKER_TEMPLATE = '> [ ... %d lines skipped ... ]' | |
| # -------------------------------------------------------------------------- | |
| # Layer 1: format-contract tests (no editor required). | |
| # -------------------------------------------------------------------------- | |
| # A small diff and a review set exercising every rendered line category: an | |
| # own (unquoted) comment and an external reviewer comment with attribution, | |
| # a multi-line body and a "via:" provenance line. | |
| _CONTRACT_DIFF = """\ | |
| diff --git a/f.c b/f.c | |
| --- a/f.c | |
| +++ b/f.c | |
| @@ -1,3 +1,4 @@ | |
| int x; | |
| +int y; | |
| int z; | |
| """ | |
| _CONTRACT_REVIEWS: Dict[str, Dict[str, object]] = { | |
| 'me@example.com': { | |
| 'comments': [{'path': 'b/f.c', 'line': 2, 'text': 'looks good'}], | |
| }, | |
| 'rev@example.com': { | |
| 'name': 'Rev Iewer', | |
| 'provenance': 'agent-foo', | |
| 'comments': [ | |
| {'path': 'b/f.c', 'line': 2, 'text': 'are you sure?\nmaybe not'}, | |
| ], | |
| }, | |
| } | |
| def _contract_buffer() -> str: | |
| return _render_quoted_diff_with_comments( | |
| _CONTRACT_DIFF, _CONTRACT_REVIEWS, 'me@example.com' | |
| ) | |
| def test_external_comment_lines_follow_plugin_contract() -> None: | |
| """Every ``|`` line is ``"| "``-prefixed or bare ``"|"``. | |
| The plugins' "adopt comment" and highlighting both key off exactly this | |
| shape, including a ``| Name <addr>:`` header and a ``| via:`` line. | |
| """ | |
| buf = _contract_buffer() | |
| pipe_lines = [ln for ln in buf.splitlines() if ln.startswith('|')] | |
| assert pipe_lines, 'expected the external review to render | lines' | |
| for ln in pipe_lines: | |
| assert ln == '|' or ln.startswith('| '), f'bad external line: {ln!r}' | |
| # The attribution header and provenance lines the adopt command drops. | |
| assert any(ln.endswith('>:') for ln in pipe_lines), 'no attribution header' | |
| assert any(ln.startswith('| via: ') for ln in pipe_lines), 'no via: line' | |
| def test_quoted_and_instruction_prefixes() -> None: | |
| """Quoted lines are ``"> "`` or bare ``">"``; instructions start with ``#``.""" | |
| buf = _contract_buffer() | |
| lines = buf.splitlines() | |
| assert any(ln.startswith('#') for ln in lines), 'no instruction lines' | |
| for ln in lines: | |
| if ln.startswith('>'): | |
| assert ln == '>' or ln.startswith('> '), f'bad quoted line: {ln!r}' | |
| if ln.startswith('#'): | |
| # Instruction lines follow the same shape as quoted ones: a bare | |
| # "#" separator, or "# " followed by text. The plugins key their | |
| # highlighting off exactly this prefix. | |
| assert ln == '#' or (ln.startswith('# ') and ln.strip('# ')), ( | |
| f'bad instruction line: {ln!r}' | |
| ) | |
| def test_skip_markers_are_inert_to_parser() -> None: | |
| """A plugin-inserted skip marker is quoted, so b4's parser ignores it. | |
| The marker is a reading aid the plugins drop into the ``> ``-quoted diff; | |
| it must never come back out as one of the reviewer's own comments. | |
| """ | |
| buf = _contract_buffer() | |
| # Splice a marker in among the quoted diff, as the plugins would. | |
| lines = buf.splitlines() | |
| spliced = [] | |
| for ln in lines: | |
| spliced.append(ln) | |
| if ln == '> +int y;': | |
| spliced.append(_MARKER_TEMPLATE % 7) | |
| comments = _extract_editor_comments('\n'.join(spliced) + '\n') | |
| texts = [c['text'] for c in comments] | |
| assert any('looks good' in t for t in texts), 'own comment should survive' | |
| assert not any('lines skipped' in t for t in texts), 'marker leaked into a comment' | |
| def test_skip_marker_template_consistent_across_plugins() -> None: | |
| """Both plugins write the marker with the one identical template.""" | |
| vim_src = _VIM_FTPLUGIN.read_text() | |
| el_src = _EL_MODE.read_text() | |
| assert _MARKER_TEMPLATE in vim_src, 'vim ftplugin lost the marker template' | |
| assert _MARKER_TEMPLATE in el_src, 'emacs mode lost the marker template' | |
| # -------------------------------------------------------------------------- | |
| # Layer 2: behavioural tests driving the real editors. | |
| # -------------------------------------------------------------------------- | |
| _VIM = shutil.which('vim') | |
| _EMACS = shutil.which('emacs') | |
| # Logical operation -> how to perform it in each editor. vim ops are appended | |
| # with ":wq\r" by the driver; the command ops are ex commands, "delete3" is the | |
| # raw normal-mode keystrokes for a three-line delete (exercising the auto | |
| # marker, which only fires through the real normal-mode loop). | |
| _VIM_KEYS: Dict[str, str] = { | |
| 'adopt': ':B4Adopt\r', | |
| 'delhunk': ':B4DelHunk\r', | |
| 'delbefore': ':B4DelHunksBefore\r', | |
| 'delete3': '3dd', | |
| } | |
| _EL_OPS: Dict[str, str] = { | |
| 'adopt': '(b4-review-adopt-comment)', | |
| 'delhunk': '(b4-review-delete-hunk)', | |
| 'delbefore': '(b4-review-delete-hunks-before)', | |
| 'delete3': ( | |
| '(let ((b (line-beginning-position)))' | |
| ' (forward-line 3) (delete-region b (point)))' | |
| ), | |
| } | |
| class Case(NamedTuple): | |
| cid: str | |
| text: str | |
| line: int # 1-based line to place the cursor on before the op | |
| op: str | |
| auto: bool # enable the opt-in auto-marker (only meaningful for delete3) | |
| expected: str | |
| def _norm(text: str) -> str: | |
| """Collapse trailing blank lines to a single newline. | |
| vim leaves one extra empty line when a delete reduces the buffer entirely | |
| to a marker (an emptied buffer still holds vim's mandatory single line); | |
| emacs does not. The reply format treats trailing blanks as insignificant | |
| -- b4 strips them on send -- so the comparison ignores them rather than | |
| baking a cosmetic quirk into the expected output. | |
| """ | |
| return text.rstrip('\n') + '\n' if text.strip() else '' | |
| _ADOPT = """\ | |
| > @@ -1,3 +1,3 @@ | |
| > -old line | |
| > +new line | |
| | Reviewer Name <rev@example.com>: | |
| | | |
| | This looks wrong to me. | |
| | Second line. | |
| | | |
| | via: agent-foo | |
| """ | |
| _DELHUNK = """\ | |
| > diff --git a/f b/f | |
| > --- a/f | |
| > +++ b/f | |
| > @@ -1,2 +1,2 @@ | |
| > -a | |
| > +b | |
| > ctx | |
| """ | |
| # A hunk whose last quoted line is already a skip marker: trimming the hunk | |
| # must fold the marker's 5 into the 3 newly removed quoted lines -> 8. | |
| _COALESCE = """\ | |
| > @@ -1,2 +1,2 @@ | |
| > -a | |
| > +b | |
| > [ ... 5 lines skipped ... ] | |
| """ | |
| _TWOHUNK = """\ | |
| > diff --git a/f b/f | |
| > --- a/f | |
| > +++ b/f | |
| > @@ -1,2 +1,2 @@ | |
| > -a | |
| > +b | |
| > @@ -10,2 +10,2 @@ | |
| > -c | |
| > +d | |
| """ | |
| _AUTO = """\ | |
| > @@ -1,4 +1,4 @@ | |
| > -a | |
| > -b | |
| > -c | |
| > +d | |
| """ | |
| CASES: List[Case] = [ | |
| # Adopt strips "| ", drops the attribution + via lines, trims the blank | |
| # "|" lines around the body. | |
| Case( | |
| cid='adopt', | |
| text=_ADOPT, | |
| line=6, | |
| op='adopt', | |
| auto=False, | |
| expected=( | |
| '> @@ -1,3 +1,3 @@\n> -old line\n> +new line\n' | |
| 'This looks wrong to me.\nSecond line.\n' | |
| ), | |
| ), | |
| # Adopt on a quoted "> " line is a no-op (not on a | comment). | |
| Case( | |
| cid='adopt-noop', | |
| text=_TWOHUNK, | |
| line=5, | |
| op='adopt', | |
| auto=False, | |
| expected=_norm(_TWOHUNK), | |
| ), | |
| # Delete the hunk under the cursor: header + 3 quoted lines -> one marker. | |
| Case( | |
| cid='delhunk', | |
| text=_DELHUNK, | |
| line=5, | |
| op='delhunk', | |
| auto=False, | |
| expected=( | |
| '> diff --git a/f b/f\n> --- a/f\n> +++ b/f\n' | |
| '> [ ... 4 lines skipped ... ]\n' | |
| ), | |
| ), | |
| # Adjacent markers coalesce: 3 trimmed + the existing 5 -> 8. | |
| Case( | |
| cid='coalesce', | |
| text=_COALESCE, | |
| line=2, | |
| op='delhunk', | |
| auto=False, | |
| expected='> [ ... 8 lines skipped ... ]\n', | |
| ), | |
| # Trim the hunk(s) above the current one; the file header is preserved and | |
| # the second hunk is left intact. | |
| Case( | |
| cid='delbefore', | |
| text=_TWOHUNK, | |
| line=8, | |
| op='delbefore', | |
| auto=False, | |
| expected=( | |
| '> diff --git a/f b/f\n> --- a/f\n> +++ b/f\n' | |
| '> [ ... 3 lines skipped ... ]\n' | |
| '> @@ -10,2 +10,2 @@\n> -c\n> +d\n' | |
| ), | |
| ), | |
| # Opt-in auto-marker: a plain 3-line delete of quoted lines leaves a marker | |
| # counting only the quoted (>) lines removed. | |
| Case( | |
| cid='auto-marker', | |
| text=_AUTO, | |
| line=2, | |
| op='delete3', | |
| auto=True, | |
| expected='> @@ -1,4 +1,4 @@\n> [ ... 3 lines skipped ... ]\n> +d\n', | |
| ), | |
| ] | |
| _CASE_IDS = [c.cid for c in CASES] | |
| def _run_vim(tmp_path: pathlib.Path, case: Case) -> str: | |
| target = tmp_path / 't.b4-review.eml' | |
| keys = tmp_path / 'keys' | |
| target.write_text(case.text) | |
| keys.write_text(_VIM_KEYS[case.op] + ':wq\r') | |
| cmd = [ | |
| 'vim', | |
| '-N', | |
| '-u', | |
| 'NONE', | |
| '-T', | |
| 'dumb', | |
| '--not-a-term', | |
| '-c', | |
| f'set runtimepath^={_VIM_RTP}', | |
| ] | |
| if case.auto: | |
| cmd += ['-c', 'let g:b4review_auto_marker=1'] | |
| cmd += [ | |
| '-c', | |
| 'filetype plugin on', | |
| '-c', | |
| f'edit {target}', | |
| '-c', | |
| 'setlocal filetype=b4review', | |
| '-c', | |
| str(case.line), | |
| '-s', | |
| str(keys), | |
| ] | |
| subprocess.run( | |
| cmd, | |
| cwd=str(tmp_path), | |
| stdout=subprocess.DEVNULL, | |
| stderr=subprocess.DEVNULL, | |
| timeout=30, | |
| check=False, | |
| ) | |
| return target.read_text() | |
| def _run_emacs(tmp_path: pathlib.Path, case: Case) -> str: | |
| infile = tmp_path / 'in.eml' | |
| outfile = tmp_path / 'out.eml' | |
| driver = tmp_path / 'drv.el' | |
| infile.write_text(case.text) | |
| setvar = '(setq b4-review-auto-marker t)' if case.auto else '' | |
| driver.write_text( | |
| f'(load "{_EL_MODE}" nil t)\n' | |
| f'{setvar}\n' | |
| '(with-temp-buffer\n' | |
| f' (insert-file-contents "{infile}")\n' | |
| ' (b4-review-mode)\n' | |
| ' (goto-char (point-min))\n' | |
| f' (forward-line {case.line - 1})\n' | |
| f' {_EL_OPS[case.op]}\n' | |
| f' (write-region (point-min) (point-max) "{outfile}"))\n' | |
| ) | |
| subprocess.run( | |
| ['emacs', '-Q', '-batch', '-l', str(driver)], | |
| stdout=subprocess.DEVNULL, | |
| stderr=subprocess.DEVNULL, | |
| timeout=30, | |
| check=False, | |
| ) | |
| return outfile.read_text() | |
| @pytest.mark.skipif(not _VIM, reason='vim not installed') | |
| @pytest.mark.parametrize('case', CASES, ids=_CASE_IDS) | |
| def test_vim_plugin_behaviour(case: Case, tmp_path: pathlib.Path) -> None: | |
| assert _norm(_run_vim(tmp_path, case)) == case.expected | |
| @pytest.mark.skipif(not _EMACS, reason='emacs not installed') | |
| @pytest.mark.parametrize('case', CASES, ids=_CASE_IDS) | |
| def test_emacs_plugin_behaviour(case: Case, tmp_path: pathlib.Path) -> None: | |
| assert _norm(_run_emacs(tmp_path, case)) == case.expected |