Branches view initial version
This commit is contained in:
Vaclav Tvrdik
763
tests/test_branches.py
Normal file
763
tests/test_branches.py
Normal file
@@ -0,0 +1,763 @@
|
||||
import pytest
|
||||
|
||||
import sublime # the stub, via conftest
|
||||
|
||||
from conftest import put_caret # noqa: E402
|
||||
from test_render import header, with_loaded_override # noqa: E402
|
||||
from vdiff import branches, commands, git, listeners, palette, render, state
|
||||
|
||||
|
||||
def ref(name, remote=None, upstream=None, ahead=0, behind=0, gone=False, current=False, sha="abc1234", upstream_remote=""):
|
||||
"""A Ref; the upstream's remote is read off its name unless given (None for a local upstream)"""
|
||||
branch = name.partition("/")[2] if remote else name
|
||||
if upstream_remote == "":
|
||||
upstream_remote = upstream.partition("/")[0] if upstream else None
|
||||
return git.Ref(name, branch, remote, sha, upstream, ahead, behind, gone, current, upstream_remote)
|
||||
|
||||
|
||||
def commit(subject, tags=(), files=8, insertions=260, deletions=58, sha="1" * 40):
|
||||
return git.Commit(sha, sha[:7], "vtvrdik", "20.12.2025", subject, files, insertions, deletions, tuple(tags))
|
||||
|
||||
|
||||
REFS = [
|
||||
ref("feature"),
|
||||
ref("main", upstream="origin/main", ahead=1, current=True),
|
||||
ref("github/main", remote="github"),
|
||||
ref("origin/main", remote="origin"),
|
||||
]
|
||||
COMMITS = [
|
||||
commit("default file view mode and some colors now configurable in settings", tags=("v1.1.0",), sha="a" * 40),
|
||||
commit("next commit message", files=None, insertions=None, deletions=None, sha="b" * 40),
|
||||
]
|
||||
|
||||
|
||||
def make_state(refs=REFS, commits=COMMITS, selected="main", remotes=("origin", "github")):
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
st.mode = state.MODE_BRANCHES
|
||||
st.branch_refs = list(refs)
|
||||
st.branch_remotes = list(remotes)
|
||||
st.branch_commits = list(commits)
|
||||
st.branch_ref = selected
|
||||
st.branch_head_sha = "abc1234"
|
||||
return st
|
||||
|
||||
|
||||
def rendered(st=None, live=False):
|
||||
"""A drawn branches view; `live` models a scheme that has picked up the override, as after a restart"""
|
||||
view = with_loaded_override(sublime.View()) if live else sublime.View()
|
||||
render.init_view(view)
|
||||
st = st or make_state()
|
||||
branches.render_branches(view, st)
|
||||
return view, st
|
||||
|
||||
|
||||
def rows(view):
|
||||
return view.text.split("\n")[1:]
|
||||
|
||||
|
||||
class Calls:
|
||||
"""Records the git helper calls an action makes; `answer` is what a worker returns"""
|
||||
|
||||
def __init__(self, monkeypatch, answer=None):
|
||||
self.calls = []
|
||||
self.answer = answer
|
||||
for name in ("checkout", "checkout_detached", "pull", "fetch_into", "push", "fetch_all", "delete_branch"):
|
||||
monkeypatch.setattr(branches.git, name, self._record(name))
|
||||
self.loads = record_loads(monkeypatch)
|
||||
|
||||
def _record(self, name):
|
||||
def call(*args, **kwargs):
|
||||
self.calls.append((name, args[1:], kwargs))
|
||||
if isinstance(self.answer, Exception):
|
||||
raise self.answer
|
||||
return self.answer
|
||||
|
||||
return call
|
||||
|
||||
|
||||
def record_loads(monkeypatch):
|
||||
"""Replace branches.load with a recorder of (branch, mode, message, keep_caret) per call"""
|
||||
loads = []
|
||||
|
||||
def fake_load(view, st, message=None, keep_caret=False):
|
||||
loads.append((st.branch_ref, st.mode, message, keep_caret))
|
||||
|
||||
monkeypatch.setattr(branches, "load", fake_load)
|
||||
return loads
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def calls(monkeypatch):
|
||||
return Calls(monkeypatch)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def loads(monkeypatch):
|
||||
return record_loads(monkeypatch)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def dialogs(monkeypatch):
|
||||
monkeypatch.setattr(sublime, "dialogs", [])
|
||||
monkeypatch.setattr(sublime, "dialog_answer", True)
|
||||
return sublime.dialogs
|
||||
|
||||
|
||||
# --- drawing ----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_two_columns_are_laid_out_as_in_the_mockup():
|
||||
view, st = rendered()
|
||||
lines = rows(view)
|
||||
# the left column is as wide as its longest cell plus the padding; the gap follows it
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
assert all(line[width:width + 2] == "| " for line in lines)
|
||||
right = 100 - width - 2
|
||||
# the working tree comes first, five rows like a commit; nothing changed here
|
||||
assert lines[0] == f"{'BRANCHES':<{width}}| No Changes"
|
||||
assert lines[1] == f"{' feature':<{width}}| "
|
||||
# main is one commit ahead of its upstream: the count sits on the right edge of its cell
|
||||
assert lines[2] == f"{'* main':<{width - 3}}↑1 | "
|
||||
assert lines[3] == f"{'REMOTES':<{width}}| "
|
||||
assert lines[4] == f"{'origin':<{width}}| " + "-" * right
|
||||
assert lines[5] == f"{' main':<{width}}| default file view mode and some colors now configurable in settings"
|
||||
assert lines[6].startswith(f"{'github':<{width}}| Author: vtvrdik")
|
||||
# the tag sits on the right edge of the author row
|
||||
assert lines[6].endswith("v1.1.0") and len(lines[6]) == width + 2 + right
|
||||
assert lines[7] == f"{' main':<{width}}| Date: 20.12.2025"
|
||||
# the left column ran out, so the cells are blank
|
||||
assert lines[8] == f"{'':<{width}}| Stats: 8 files changed -58 +260"
|
||||
assert lines[9] == f"{'':<{width}}| " + "-" * right
|
||||
assert lines[10] == f"{'':<{width}}| next commit message"
|
||||
assert lines[11].rstrip() == f"{'':<{width}}| Author: vtvrdik"
|
||||
# no diffstat for a merge or an empty commit
|
||||
assert lines[13] == f"{'':<{width}}| Stats: (no diffstat)"
|
||||
assert lines[14] == f"{'':<{width}}| " + "-" * right
|
||||
assert len(lines) == 15
|
||||
assert view.syntax == "scope:text.plain"
|
||||
assert view.name_ == "⟐ branches"
|
||||
|
||||
|
||||
CHANGES = [
|
||||
git.FileChange("a.py", "M", False, 1, 1, None, unstaged=True),
|
||||
git.FileChange("b.txt", "M", True, 1, 0, None),
|
||||
git.FileChange("c.txt", "M", True, 2, 0, None, unstaged=True), # partially staged: counted on both sides
|
||||
git.FileChange("img.png", "M", True, None, None, None), # binary: no counts
|
||||
]
|
||||
|
||||
|
||||
def test_the_working_tree_entry_counts_the_staged_and_unstaged_files_and_their_diffstat():
|
||||
st = make_state()
|
||||
st.branch_changes = list(CHANGES)
|
||||
view, st = rendered(st)
|
||||
lines = rows(view)
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
assert lines[0] == f"{'BRANCHES':<{width}}| 3 staged files, 2 unstaged files"
|
||||
assert lines[1] == f"{' feature':<{width}}| Stats: 4 files changed -1 +4"
|
||||
assert lines[2] == f"{'* main':<{width - 3}}↑1 | " and lines[3] == f"{'REMOTES':<{width}}| "
|
||||
assert lines[4].endswith("-" * 10) and lines[5].endswith("| default file view mode and some colors now configurable in settings")
|
||||
# its counts are coloured like the commits', in row order
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_DEL][0]] == ["-1", "-58"]
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["+4", "v1.1.0", "+260"]
|
||||
# the singular
|
||||
st.branch_changes = [CHANGES[0]]
|
||||
branches.render_branches(view, st)
|
||||
assert rows(view)[0] == f"{'BRANCHES':<{width}}| 0 staged files, 1 unstaged file"
|
||||
st.branch_changes = [CHANGES[1]]
|
||||
branches.render_branches(view, st)
|
||||
assert rows(view)[0] == f"{'BRANCHES':<{width}}| 1 staged file, 0 unstaged files"
|
||||
|
||||
|
||||
def test_local_branches_show_their_standing_against_the_upstream():
|
||||
refs = [ref("level", upstream="origin/level"), ref("ahead", upstream="origin/ahead", ahead=3, current=True),
|
||||
ref("both", upstream="origin/both", ahead=12, behind=4), ref("lost", upstream="origin/lost", gone=True),
|
||||
ref("untracked"), ref("origin/level", remote="origin")]
|
||||
view, st = rendered(make_state(refs=refs, selected="ahead", remotes=("origin",)))
|
||||
cells = [line.split("| ")[0] for line in rows(view)]
|
||||
width = len(" both ↑12 ↓4") + branches.LEFT_PAD
|
||||
# in the listing's order; level and untracked branches carry nothing, nor do remote ones
|
||||
assert cells[1:6] == [f"{' level':<{width}}", f"{'* ahead':<{width - 3}}↑3 ", f"{' both':<{width - 7}}↑12 ↓4 ",
|
||||
f"{' lost':<{width - 5}}gone ", f"{' untracked':<{width}}"]
|
||||
assert cells[7] == f"{'origin':<{width}}" and cells[8] == f"{' level':<{width}}"
|
||||
# ahead is green, behind and gone red; the selected branch's standing is painted apart, on its background
|
||||
def painted(key):
|
||||
"""The coloured texts under a key"""
|
||||
return [view.text[r.a:r.b] for r in view.regions[key][0]]
|
||||
|
||||
assert painted(render.KEY_BRANCH_STANDING_INS) == ["↑12"] and painted(render.KEY_BRANCH_STANDING_DEL) == ["↓4", "gone"]
|
||||
assert painted(render.KEY_BRANCH_SEL_INS) == ["↑3"] and painted(render.KEY_BRANCH_SEL_DEL) == []
|
||||
# moving the selection moves the standing between the keys
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "both"
|
||||
assert painted(render.KEY_BRANCH_STANDING_INS) == ["↑3"] and painted(render.KEY_BRANCH_STANDING_DEL) == ["gone"]
|
||||
assert painted(render.KEY_BRANCH_SEL_INS) == ["↑12"] and painted(render.KEY_BRANCH_SEL_DEL) == ["↓4"]
|
||||
# a long name gives way to its counts, never the other way round
|
||||
long = ref("feature/" + "x" * 60, upstream="origin/x", behind=2)
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True), long], selected="main"))
|
||||
cell = rows(view)[2][:branches.LEFT_MAX]
|
||||
assert cell.endswith("↓2 ") and "…" in cell and len(cell) == branches.LEFT_MAX
|
||||
|
||||
|
||||
def test_rows_know_their_branch_and_commit():
|
||||
view, st = rendered()
|
||||
# item 0 is the working tree, the commits follow from 1
|
||||
assert [(r.ref and r.ref.name, r.commit) for r in st.branch_rows] == [
|
||||
(None, 0), ("feature", 0), ("main", 0), (None, 0), (None, 0),
|
||||
("origin/main", 1), (None, 1), ("github/main", 1), (None, 1), (None, 1),
|
||||
(None, 2), (None, 2), (None, 2), (None, 2), (None, 2),
|
||||
]
|
||||
|
||||
|
||||
def test_a_remote_without_fetched_branches_keeps_its_row():
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True)], remotes=("origin", "gitea")))
|
||||
names = [line.split("|")[0].rstrip() for line in rows(view)]
|
||||
assert names[:5] == ["BRANCHES", "* main", "REMOTES", "origin", "gitea"]
|
||||
|
||||
|
||||
def test_long_branch_names_are_clipped_at_the_cap():
|
||||
long = "feature/" + "x" * 60
|
||||
view, st = rendered(make_state(refs=[ref("main", current=True), ref(long)], selected="main"))
|
||||
width = branches.LEFT_MAX
|
||||
assert rows(view)[2].startswith(f"{' ' + long[:width - 4]}…" + " | ") or rows(view)[2][width:width + 2] == "| "
|
||||
assert rows(view)[2][:width].rstrip().endswith("…")
|
||||
|
||||
|
||||
def test_selection_headings_tags_and_counts_are_painted():
|
||||
view, st = rendered()
|
||||
width = len(" feature") + branches.LEFT_PAD
|
||||
starts = render._row_starts_for_text(rows(view))
|
||||
selected, scope, _, _ = view.regions[render.KEY_BRANCH_SEL]
|
||||
assert selected == [sublime.Region(starts[2], starts[2] + width)]
|
||||
assert scope == render._file_header_scope(view)
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_DEL][0]] == ["-58"]
|
||||
# the tags are green like the insertions, in row order; main's ↑1 sits on the selected row
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["v1.1.0", "+260"]
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_SEL_INS][0]] == ["↑1"]
|
||||
assert view.regions[render.KEY_BRANCH_STANDING_INS][0] == []
|
||||
# filled regions, since only those take the scope's text colour; the scheme's tint stands in until the
|
||||
# override's red/green-on-background rules are live, after which the text is red / green on the editor
|
||||
# background, or on the heading background along the selected row so its tint runs through the standing
|
||||
assert not view.regions[render.KEY_BRANCH_DEL][3] & sublime.DRAW_NO_FILL
|
||||
assert view.regions[render.KEY_BRANCH_DEL][1] == palette.SCOPE_DEL
|
||||
assert view.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_INS
|
||||
assert view.regions[render.KEY_BRANCH_SEL_INS][1] == palette.SCOPE_INS
|
||||
live, _ = rendered(live=True)
|
||||
assert live.regions[render.KEY_BRANCH_DEL][1] == palette.SCOPE_TEXT_DEL
|
||||
assert live.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_TEXT_INS
|
||||
assert live.regions[render.KEY_BRANCH_STANDING_DEL][1] == palette.SCOPE_TEXT_DEL
|
||||
assert live.regions[render.KEY_BRANCH_SEL_DEL][1] == palette.SCOPE_FILE_DEL_COUNT
|
||||
assert live.regions[render.KEY_BRANCH_SEL_INS][1] == palette.SCOPE_FILE_INS_COUNT
|
||||
|
||||
|
||||
def test_caret_starts_on_the_working_tree_entry_and_stays_on_its_item_across_a_refresh():
|
||||
view, st = rendered()
|
||||
assert view.sel()[0].a == render.index_point(view, 0) and st.branch_rows[0].commit == branches.WORKTREE
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == branches.ROWS_PER_COMMIT
|
||||
branches.render_branches(view, st, keep_caret=True)
|
||||
assert render.caret_index(view) == branches.ROWS_PER_COMMIT
|
||||
# a plain redraw goes back to the top
|
||||
branches.render_branches(view, st)
|
||||
assert render.caret_index(view) == 0
|
||||
|
||||
|
||||
def test_no_commits_and_no_branches_still_draw():
|
||||
view, st = rendered(make_state(refs=[], commits=[], selected=None, remotes=()))
|
||||
rule = "-" * (100 - len("BRANCHES | "))
|
||||
assert rows(view) == ["BRANCHES | No Changes", "REMOTES | ", " | ", " | ", " | " + rule,
|
||||
" | (no commits)"]
|
||||
# the one item to step through is the working tree
|
||||
assert view.sel()[0].a == render.index_point(view, 0)
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 0
|
||||
assert view.regions[render.KEY_BRANCH_SEL][0] == []
|
||||
assert "no branch selected" in header(view)
|
||||
|
||||
|
||||
def test_render_sets_the_mode_and_persists_the_branch():
|
||||
view, st = rendered()
|
||||
assert view.settings().get(state.MODE_SETTING) == "branches"
|
||||
assert view.settings().get(state.VIEW_DATA) == {"repo": "/repo/vdiff", "sha": None, "mode": "branches", "ref": "main"}
|
||||
assert view.status[render.STATUS_KEY] == render.key_hints("branches")
|
||||
assert st.fingerprint == ((), (None,)) # no ref paths and no index outside a repository
|
||||
# a diff render switches back
|
||||
st.change = git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
render.render_message(view, st, "nothing")
|
||||
assert view.settings().get(state.MODE_SETTING) == "diff"
|
||||
assert "mode" not in view.settings().get(state.VIEW_DATA)
|
||||
assert view.status[render.STATUS_KEY] == render.key_hints()
|
||||
assert render.KEY_BRANCH_SEL not in view.regions
|
||||
|
||||
|
||||
def test_an_unchanged_header_is_not_redrawn():
|
||||
view, st = rendered()
|
||||
first = view.phantoms[render.PHANTOM_KEY][0]
|
||||
# the same header over the same text keeps the phantom in place
|
||||
render._header(view, st, st.header[0])
|
||||
assert view.phantoms[render.PHANTOM_KEY] == [first]
|
||||
# new text may have dropped the phantom, so it is drawn again even for the same header
|
||||
branches.render_branches(view, st, keep_caret=True)
|
||||
assert view.phantoms[render.PHANTOM_KEY][0] is not first and len(view.phantoms[render.PHANTOM_KEY]) == 1
|
||||
|
||||
|
||||
def test_header_shows_head_upstream_and_the_links_of_the_selected_kind():
|
||||
view, st = rendered()
|
||||
text = header(view)
|
||||
assert "Branches · vdiff" in text and ">main<" in text and "on <span" in text
|
||||
# the standing as the cell shows it: a zero count is left out
|
||||
assert "→ origin/main" in text and '<span class="ins">↑1</span>' in text and "↓0" not in text
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", behind=2, current=True)
|
||||
branches.render_branches(view, st)
|
||||
assert '<span class="del">↓2</span>' in header(view) and "↑0" not in header(view)
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", current=True)
|
||||
branches.render_branches(view, st)
|
||||
assert "up to date" in header(view)
|
||||
st.branch_refs[1] = REFS[1]
|
||||
branches.render_branches(view, st)
|
||||
for link in ("checkout", "pull", "push", "fetch", "delete_branch", "files", "commits", "help"):
|
||||
assert f'href="{link}"' in text
|
||||
assert 'href="checkout_detached"' not in text
|
||||
|
||||
st.branch_ref = "origin/main"
|
||||
branches.render_branches(view, st)
|
||||
text = header(view)
|
||||
assert "remote branch of origin" in text and 'href="checkout_detached"' in text
|
||||
assert 'href="delete_branch"' not in text and 'href="pull"' not in text
|
||||
|
||||
st.branch_ref = "feature"
|
||||
st.branch_refs[1] = ref("main", upstream="origin/main", ahead=1) # nothing checked out: detached
|
||||
branches.render_branches(view, st)
|
||||
text = header(view)
|
||||
assert "detached at" in text and "abc1234" in text and "→" not in text
|
||||
st.branch_head_sha = ""
|
||||
branches.render_branches(view, st)
|
||||
assert "no commits" in header(view)
|
||||
|
||||
st.branch_refs[0] = ref("feature", upstream="origin/feature", gone=True)
|
||||
branches.render_branches(view, st)
|
||||
assert ">gone<" in header(view)
|
||||
|
||||
|
||||
# --- navigation -------------------------------------------------------------
|
||||
|
||||
|
||||
def test_j_and_k_step_commits_and_ring_at_the_ends(rings):
|
||||
view, st = rendered()
|
||||
# the working tree, then the two commits
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert len(rings) == 1 and render.caret_index(view) == 0
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 10
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert len(rings) == 2 and render.caret_index(view) == 10
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
# off the items (the caret moved by the arrows onto a left-column-only row): k goes to the last, j to the first
|
||||
view, st = rendered(make_state(refs=REFS + [ref("x"), ref("y"), ref("z")], commits=COMMITS[:1]))
|
||||
assert st.branch_rows[10].commit == -1
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["prev_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 5
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
assert render.caret_index(view) == 0
|
||||
|
||||
|
||||
def test_J_and_K_select_branches_skipping_headings_and_reload_the_log(monkeypatch, rings):
|
||||
logged = []
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: logged.append(name) or [COMMITS[1]])
|
||||
view, st = rendered()
|
||||
assert st.branch_ref == "main"
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
assert st.branch_ref == "feature" and logged == ["feature"]
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
assert st.branch_ref == "feature" and len(rings) == 1
|
||||
for expected in ("main", "github/main", "origin/main"):
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == expected
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "origin/main" and len(rings) == 2
|
||||
# the stub runs the worker at once, so the log was redrawn with the new selection
|
||||
assert rows(view)[5].endswith("| next commit message")
|
||||
selected = view.regions[render.KEY_BRANCH_SEL][0]
|
||||
assert view.text[selected[0].a:selected[0].b].strip() == "main"
|
||||
# the caret went back to the working-tree entry
|
||||
assert render.caret_index(view) == 0 and st.branch_rows[0].commit == branches.WORKTREE
|
||||
|
||||
|
||||
def test_a_stale_log_is_dropped(monkeypatch):
|
||||
pending = []
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: pending.append((work, done)))
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: [commit(name)])
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["prev_branch"](view, None, st) # feature
|
||||
branches.ACTIONS["next_branch"](view, None, st) # main
|
||||
assert [name for name in (st.branch_ref,)] == ["main"] and len(pending) == 2
|
||||
# the older answer lands first, but the token moved on
|
||||
work, done = pending[0]
|
||||
done(work())
|
||||
assert "| feature" not in view.text
|
||||
work, done = pending[1]
|
||||
done(work())
|
||||
assert rows(view)[5].endswith("| main")
|
||||
|
||||
|
||||
def test_load_lists_everything_and_picks_the_branch(monkeypatch):
|
||||
monkeypatch.setattr(branches.git, "head_sha", lambda repo: "abc1234")
|
||||
monkeypatch.setattr(branches.git, "ref_paths", lambda repo: ())
|
||||
monkeypatch.setattr(branches.git, "branches", lambda repo: list(REFS))
|
||||
monkeypatch.setattr(branches.git, "remotes", lambda repo: ["origin", "github"])
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: [commit(f"log of {name}")])
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: None)
|
||||
monkeypatch.setattr(branches.git, "changed_files", lambda repo: [CHANGES[2]])
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
branches.load(view, st)
|
||||
# nothing wanted: the checked-out branch; the working tree above its log
|
||||
assert st.branch_ref == "main" and rows(view)[5].endswith("| log of main")
|
||||
assert rows(view)[0].endswith("| 1 staged file, 1 unstaged file") and rows(view)[1].endswith("| Stats: 1 file changed -0 +2")
|
||||
assert st.branch_changes == [CHANGES[2]]
|
||||
assert st.branch_remotes == ["origin", "github"] and st.branch_head_sha == "abc1234"
|
||||
assert st.token == st.rendered_token
|
||||
# a wanted branch that vanished falls back the same way
|
||||
st.branch_ref = "deleted"
|
||||
branches.load(view, st)
|
||||
assert st.branch_ref == "main"
|
||||
st.branch_ref = "origin/main"
|
||||
branches.load(view, st)
|
||||
assert st.branch_ref == "origin/main" and rows(view)[5].endswith("| log of origin/main")
|
||||
|
||||
|
||||
def test_pick_prefers_the_wanted_then_the_current_then_the_first_local_then_the_first():
|
||||
assert branches._pick(REFS, "origin/main").name == "origin/main"
|
||||
assert branches._pick(REFS, "gone").name == "main"
|
||||
detached = [ref("feature"), ref("zeta"), ref("origin/x", remote="origin")]
|
||||
assert branches._pick(detached, None).name == "feature"
|
||||
assert branches._pick([ref("origin/x", remote="origin")], None).name == "origin/x"
|
||||
assert branches._pick([], None) is None
|
||||
|
||||
|
||||
# --- actions ----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_checkout_routes_local_current_and_remote_branches(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls == [] and calls.loads == [] # already on main
|
||||
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls[-1] == ("checkout", (REFS[0], ["feature", "main"]), {})
|
||||
assert calls.loads[-1] == ("feature", "branches", "checked out feature", False)
|
||||
|
||||
st.branch_ref = "github/main"
|
||||
branches.ACTIONS["checkout"](view, None, st)
|
||||
assert calls.calls[-1][1][0].name == "github/main"
|
||||
assert st.branch_ref == "main" # the local branch of that name is what got checked out
|
||||
|
||||
st.branch_ref = "origin/main"
|
||||
branches.ACTIONS["checkout_detached"](view, None, st)
|
||||
assert calls.calls[-1] == ("checkout_detached", ("origin/main",), {})
|
||||
assert calls.loads[-1][2] == "checked out origin/main detached"
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["checkout_detached"](view, None, st)
|
||||
assert calls.calls[-1][0] == "checkout_detached" and len(calls.calls) == 3 # refused for a local branch
|
||||
|
||||
|
||||
def test_pull_pulls_the_current_branch_and_fast_forwards_another(calls):
|
||||
view, st = rendered(make_state(refs=REFS + [ref("tracked", upstream="origin/tracked", behind=2)]))
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("pull", (), {}) and calls.loads[-1][2] == "pulled main"
|
||||
st.branch_ref = "tracked"
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("fetch_into", ("origin", "tracked", "tracked"), {})
|
||||
assert calls.loads[-1][2] == "fast-forwarded tracked to origin/tracked"
|
||||
# the upstream's own name on its remote, not the local one
|
||||
st.branch_refs.append(ref("foo", upstream="origin/bar", behind=1))
|
||||
st.branch_ref = "foo"
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert calls.calls[-1] == ("fetch_into", ("origin", "bar", "foo"), {})
|
||||
st.branch_refs.append(ref("local", upstream="main", upstream_remote=None, behind=1))
|
||||
for name in ("feature", "origin/main", "local"):
|
||||
st.branch_ref = name
|
||||
branches.ACTIONS["pull"](view, None, st)
|
||||
assert len(calls.calls) == 3 # no upstream, a remote row and a local upstream: all refused
|
||||
|
||||
|
||||
def test_push_uses_the_upstream_or_sets_one_on_origin(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("origin", "main"), {"remote_branch": "main"}) and calls.loads[-1][2] == "pushed main to origin"
|
||||
# to the upstream itself when it is called differently there
|
||||
st.branch_refs.append(ref("foo", upstream="gitea/bar", ahead=2))
|
||||
st.branch_ref = "foo"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("gitea", "foo"), {"remote_branch": "bar"})
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("origin", "feature"), {"set_upstream": True})
|
||||
# without origin the first remote takes it; without any, nothing happens; nor for a local upstream
|
||||
st.branch_remotes = ["gitea"]
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert calls.calls[-1] == ("push", ("gitea", "feature"), {"set_upstream": True})
|
||||
st.branch_remotes = []
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
st.branch_ref = "origin/main"
|
||||
st.branch_remotes = ["origin"]
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
st.branch_refs.append(ref("local", upstream="main", upstream_remote=None, ahead=1))
|
||||
st.branch_ref = "local"
|
||||
branches.ACTIONS["push"](view, None, st)
|
||||
assert len(calls.calls) == 4
|
||||
|
||||
|
||||
def test_fetch_fetches_everything_and_keeps_the_cursor(calls):
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["fetch"](view, None, st)
|
||||
assert calls.calls == [("fetch_all", (), {})] and calls.loads == [("main", "branches", "fetched all remotes", True)]
|
||||
|
||||
|
||||
def test_delete_asks_then_deletes_and_asks_again_for_an_unmerged_branch(calls, dialogs, monkeypatch):
|
||||
view, st = rendered()
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert dialogs == [("Delete the branch feature?", "Delete")]
|
||||
assert calls.calls == [("delete_branch", ("feature",), {})] and calls.loads == [("feature", "branches", "deleted feature", False)]
|
||||
|
||||
# not fully merged: a second question, then the forced deletion
|
||||
calls.answer = git.GitError("error: The branch 'feature' is not fully merged.\n", 1)
|
||||
del dialogs[:]
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert [d[1] for d in dialogs] == ["Delete", "Delete anyway"]
|
||||
assert calls.calls[-1] == ("delete_branch", ("feature",), {"force": True})
|
||||
|
||||
# Cancel on the first question does nothing; so does a remote or the checked-out branch
|
||||
monkeypatch.setattr(sublime, "dialog_answer", False)
|
||||
count = len(calls.calls)
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
st.branch_ref = "main"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
st.branch_ref = "origin/main"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert len(calls.calls) == count
|
||||
|
||||
|
||||
def test_other_git_errors_from_delete_still_reach_the_status_bar(calls, dialogs, monkeypatch):
|
||||
messages = []
|
||||
monkeypatch.setattr(branches, "status", lambda m: messages.append(m))
|
||||
monkeypatch.setattr("vdiff.utils.status", lambda m: messages.append(m))
|
||||
calls.answer = git.GitError("fatal: something else\n", 1)
|
||||
view, st = rendered()
|
||||
st.branch_ref = "feature"
|
||||
branches.ACTIONS["delete_branch"](view, None, st)
|
||||
assert messages[-1] == "fatal: something else" and calls.loads == []
|
||||
|
||||
|
||||
def test_o_reviews_the_commit_under_the_caret():
|
||||
view, st = rendered()
|
||||
window = sublime.Window()
|
||||
# the working-tree entry opens the files view, which itself stays put when there is nothing to list
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert window.commands == [("vdiff_files", None)]
|
||||
branches.ACTIONS["next_commit"](view, window, st)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
branches.ACTIONS["next_commit"](view, window, st)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert window.commands[1:] == [("vdiff_commits", {"sha": "a" * 40}), ("vdiff_commits", {"sha": "b" * 40})]
|
||||
# a row without an item (the left column outran the log) opens nothing
|
||||
view, st = rendered(make_state(refs=REFS + [ref("x"), ref("y"), ref("z")], commits=COMMITS[:1]))
|
||||
put_caret(view, 10)
|
||||
branches.ACTIONS["open_commit"](view, window, st)
|
||||
assert len(window.commands) == 3
|
||||
|
||||
|
||||
def test_branch_actions_refuse_a_diff_view(calls):
|
||||
view, st = rendered()
|
||||
st.mode = state.MODE_DIFF
|
||||
for name in branches.ACTIONS:
|
||||
branches.ACTIONS[name](view, sublime.Window(), st)
|
||||
assert calls.calls == [] and calls.loads == []
|
||||
|
||||
|
||||
# --- wiring -----------------------------------------------------------------
|
||||
|
||||
|
||||
def test_b_opens_the_branches_command_and_refresh_reloads_in_place(loads):
|
||||
view, st = rendered()
|
||||
window = sublime.Window()
|
||||
commands.ACTIONS["branches"](view, window, st)
|
||||
assert window.commands == [("vdiff_branches", None)]
|
||||
commands.ACTIONS["refresh"](view, window, st)
|
||||
assert loads == [("main", "branches", None, True)]
|
||||
|
||||
|
||||
def test_restore_view_comes_back_in_branches_mode(loads, tmp_path):
|
||||
view = sublime.View()
|
||||
view.settings().set(state.VIEW_DATA, {"repo": str(tmp_path), "sha": None, "mode": "branches", "ref": "feature"})
|
||||
st = commands.restore_view(view)
|
||||
assert loads == [("feature", "branches", None, False)] and view.settings().get(state.MODE_SETTING) == "branches"
|
||||
# while the load (stubbed here) is in flight an activation does not start a second one
|
||||
st.token += 1
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1
|
||||
|
||||
|
||||
def test_esc_from_the_files_panel_goes_back_to_the_branches(monkeypatch, loads):
|
||||
monkeypatch.setattr(commands, "show_file", lambda view, st, c: None)
|
||||
view, st = rendered()
|
||||
kept = st.enter()
|
||||
assert kept.mode == "branches"
|
||||
window = sublime.Window()
|
||||
files = [git.FileChange("a.py", "M", False, 1, 1, None)]
|
||||
commands.show_files_panel(window, view, st, files, kept, placeholder="x")
|
||||
_, on_select, _, on_highlight, _ = window.panel
|
||||
on_highlight(0)
|
||||
st.mode = state.MODE_DIFF # the preview drew a diff
|
||||
on_select(-1)
|
||||
assert [m for _, m, _, _ in loads] == ["branches"] and st.in_branches
|
||||
|
||||
|
||||
def test_keymap_context_answers_the_mode():
|
||||
listener = listeners.VdiffEventListener()
|
||||
view, st = rendered()
|
||||
assert view.settings().get(state.MODE_SETTING) == "branches"
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_EQUAL, "branches", False) is True
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_EQUAL, "diff", False) is False
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_NOT_EQUAL, "diff", False) is True
|
||||
assert listener.on_query_context(view, "vdiff_mode", sublime.OP_NOT_EQUAL, "branches", False) is False
|
||||
# other keys and other views are someone else's business
|
||||
assert listener.on_query_context(view, "setting.vdiff_mode", sublime.OP_EQUAL, "branches", False) is None
|
||||
assert listener.on_query_context(sublime.View(), "vdiff_mode", sublime.OP_EQUAL, "diff", False) is None
|
||||
# a review view without the setting (an older session) is a diff view
|
||||
plain = sublime.View()
|
||||
plain.settings().set(state.VIEW_FLAG, True)
|
||||
assert listener.on_query_context(plain, "vdiff_mode", sublime.OP_EQUAL, "diff", False) is True
|
||||
|
||||
|
||||
def test_branches_view_reloads_when_the_refs_changed(monkeypatch):
|
||||
mtimes = {"/repo/.git/HEAD": 1.0, "/repo/.git/refs/heads": 2.0, "/repo/vdiff/a.py": 5.0}
|
||||
monkeypatch.setattr(branches.git, "ref_paths", lambda repo: ("/repo/.git/HEAD", "/repo/.git/refs/heads"))
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: "/repo/.git/index")
|
||||
monkeypatch.setattr(git, "mtime", lambda path: mtimes.get(path))
|
||||
loads = record_loads(monkeypatch)
|
||||
worktree_loads = []
|
||||
monkeypatch.setattr(branches, "load_worktree", lambda view, st: worktree_loads.append(st.branch_ref))
|
||||
st = make_state()
|
||||
st.branch_changes = [CHANGES[0]]
|
||||
view, st = rendered(st)
|
||||
st.rendered_token = st.token
|
||||
# the refs, then the changed files of the working-tree entry and the index they are staged in
|
||||
assert st.fingerprint == ((1.0, 2.0), (5.0, None))
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert loads == [] and worktree_loads == []
|
||||
mtimes["/repo/.git/HEAD"] = 3.0 # a checkout elsewhere: everything is relisted
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert loads == [("main", "branches", None, True)]
|
||||
st.rendered_token = st.token
|
||||
st.fingerprint = branches.fingerprint(st)
|
||||
# the changed file saved, something staged: only the working tree is relisted
|
||||
mtimes["/repo/vdiff/a.py"] = 6.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and worktree_loads == ["main"]
|
||||
st.fingerprint = branches.fingerprint(st)
|
||||
mtimes["/repo/.git/index"] = 7.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and worktree_loads == ["main", "main"]
|
||||
# not while a load is in flight
|
||||
st.token += 1
|
||||
mtimes["/repo/.git/HEAD"] = 4.0
|
||||
commands.refresh_if_changed(view, st)
|
||||
assert len(loads) == 1 and len(worktree_loads) == 2
|
||||
|
||||
|
||||
def test_load_worktree_relists_only_the_changes_and_keeps_the_caret(monkeypatch):
|
||||
listed = []
|
||||
monkeypatch.setattr(branches.git, "changed_files", lambda repo: listed.append(repo) or [CHANGES[1]])
|
||||
monkeypatch.setattr(branches.git, "index_path", lambda repo: None)
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
branches.load_worktree(view, st)
|
||||
assert listed == ["/repo/vdiff"] and st.branch_changes == [CHANGES[1]]
|
||||
assert rows(view)[0].endswith("| 1 staged file, 0 unstaged files") and rows(view)[5].endswith("| default file view mode and some colors now configurable in settings")
|
||||
assert render.caret_index(view) == 5 and st.token == st.rendered_token
|
||||
# a later load wins over a slower relisting
|
||||
pending = []
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: pending.append((work, done)))
|
||||
branches.load_worktree(view, st)
|
||||
st.token += 1
|
||||
work, done = pending[0]
|
||||
done([])
|
||||
assert st.branch_changes == [CHANGES[1]]
|
||||
|
||||
|
||||
def test_the_commit_cursor_tints_only_the_right_column_once_its_rule_is_live():
|
||||
# before the restart: Sublime's line highlight, no cursor regions
|
||||
view, st = rendered()
|
||||
assert view.settings().get("highlight_line") is True
|
||||
assert render.KEY_BRANCH_CURSOR not in view.regions
|
||||
# after it: the four cells of the caret's commit, from the gap to the end of the row
|
||||
view, st = rendered(live=True)
|
||||
assert view.settings().get("highlight_line") is False
|
||||
regions, scope, _, _ = view.regions[render.KEY_BRANCH_CURSOR]
|
||||
assert scope == palette.SCOPE_CURSOR
|
||||
width = len(" feature") + branches.LEFT_PAD + 2
|
||||
lines = rows(view)
|
||||
assert [view.text[r.a:r.b] for r in regions] == [line[width:] for line in lines[:4]]
|
||||
# the commits' counts and tags keep the plain red / green
|
||||
assert [view.text[r.a:r.b] for r in view.regions[render.KEY_BRANCH_INS][0]] == ["v1.1.0", "+260"]
|
||||
assert view.regions[render.KEY_BRANCH_INS][1] == palette.SCOPE_TEXT_INS
|
||||
assert view.regions[render.KEY_BRANCH_CURSOR_INS][0] == [] and view.regions[render.KEY_BRANCH_CURSOR_DEL][0] == []
|
||||
branches.ACTIONS["next_commit"](view, None, st)
|
||||
regions = view.regions[render.KEY_BRANCH_CURSOR][0]
|
||||
assert regions[0].a == render.index_point(view, 5) + width
|
||||
# the tint leaves out the counts and tags, which get the cursor's background with their own colour instead:
|
||||
# overlapping regions would let the later one recolour the text
|
||||
text = lambda key: [view.text[r.a:r.b] for r in view.regions[key][0]] # noqa: E731
|
||||
assert text(render.KEY_BRANCH_CURSOR_INS) == ["v1.1.0", "+260"] and text(render.KEY_BRANCH_CURSOR_DEL) == ["-58"]
|
||||
assert view.regions[render.KEY_BRANCH_CURSOR_INS][1] == palette.SCOPE_CURSOR_INS
|
||||
assert text(render.KEY_BRANCH_INS) == [] and text(render.KEY_BRANCH_DEL) == []
|
||||
pieces = sorted(sum((list(view.regions[key][0]) for key in (render.KEY_BRANCH_CURSOR, render.KEY_BRANCH_CURSOR_INS,
|
||||
render.KEY_BRANCH_CURSOR_DEL)), []), key=lambda r: r.a)
|
||||
assert all(a.b <= b.a for a, b in zip(pieces, pieces[1:]))
|
||||
by_row = {}
|
||||
for r in pieces:
|
||||
by_row.setdefault(view.rowcol(r.a)[0] - 1, []).append(view.text[r.a:r.b])
|
||||
assert {row: "".join(parts) for row, parts in by_row.items()} == {i: lines[i][width:] for i in range(5, 9)}
|
||||
# back in a diff the line highlight returns
|
||||
st.change = git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
render.render_message(view, st, "nothing")
|
||||
assert view.settings().get("highlight_line") is True
|
||||
|
||||
|
||||
def test_holding_J_fetches_the_log_once_the_key_rests(monkeypatch):
|
||||
timers = []
|
||||
monkeypatch.setattr(sublime, "set_timeout", lambda fn, delay=0: timers.append((fn, delay)))
|
||||
logged = []
|
||||
monkeypatch.setattr(branches.git, "ref_log", lambda repo, name, count: logged.append(name) or [])
|
||||
view, st = rendered()
|
||||
branches.ACTIONS["prev_branch"](view, None, st)
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
branches.ACTIONS["next_branch"](view, None, st)
|
||||
assert st.branch_ref == "github/main" and logged == []
|
||||
assert [delay for _, delay in timers] == [branches.DEBOUNCE_MS] * 3
|
||||
for fn, _ in timers:
|
||||
fn()
|
||||
# only the last selection's fetch ran; the cell moved at once each time
|
||||
assert logged == ["github/main"]
|
||||
selected = view.regions[render.KEY_BRANCH_SEL][0]
|
||||
assert view.text[selected[0].a:selected[0].b].strip() == "main"
|
||||
|
||||
|
||||
def test_entering_the_branches_view_vacates_the_diff_state(monkeypatch):
|
||||
monkeypatch.setattr(branches, "run_async", lambda work, done: None)
|
||||
view = sublime.View()
|
||||
render.init_view(view)
|
||||
st = state.ViewState("/repo/vdiff")
|
||||
st.sha, st.change = "abc", git.FileChange("x.py", "M", False, 1, 1, None)
|
||||
st.files = [st.change]
|
||||
branches.load(view, st)
|
||||
assert st.in_branches and st.sha is None and st.change is None and st.requested is None and st.lines == []
|
||||
assert st.files == [st.change] or st.files == [git.FileChange("x.py", "M", False, 1, 1, None)]
|
||||
Reference in New Issue
Block a user