import re

import subprocess

import pytest

from .conftest import strip_ansi_colours

@pytest.mark.parametrize("format_flag", ["", "--format=full", "--format=fuller"])

def test_log(commit_env_config, git2cpp_path, tmp_path, format_flag):

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

p = tmp_path / "mook_file.txt"

p.write_text("")

cmd_add = [git2cpp_path, "add", "mook_file.txt"]

p_add = subprocess.run(cmd_add, cwd=tmp_path, text=True)

assert p_add.returncode == 0

cmd_commit = [git2cpp_path, "commit", "-m", "test commit"]

p_commit = subprocess.run(cmd_commit, cwd=tmp_path, text=True)

assert p_commit.returncode == 0

cmd_log = [git2cpp_path, "log"]

if format_flag != "":

cmd_log.append(format_flag)

p_log = subprocess.run(cmd_log, capture_output=True, cwd=tmp_path, text=True)

assert p_log.returncode == 0

assert "Jane Doe" in p_log.stdout

assert "test commit" in p_log.stdout

if format_flag == "":

assert "Commit" not in p_log.stdout

else:

assert "Commit" in p_log.stdout

if format_flag == "--format=full":

assert "Date" not in p_log.stdout

else:

assert "CommitDate" in p_log.stdout

def test_log_nogit(commit_env_config, git2cpp_path, tmp_path):

cmd_log = [git2cpp_path, "log"]

p_log = subprocess.run(cmd_log, capture_output=True, cwd=tmp_path, text=True)

assert p_log.returncode != 0

assert "error: could not find repository at" in p_log.stderr

@pytest.mark.parametrize("max_count_flag", ["", "-n", "--max-count"])

def test_max_count(

repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path, max_count_flag

):

assert (tmp_path / "initial.txt").exists()

p2 = tmp_path / "second.txt"

p2.write_text("second file")

cmd_add2 = [git2cpp_path, "add", "second.txt"]

subprocess.run(cmd_add2, capture_output=True, cwd=tmp_path, text=True, check=True)

cmd_commit2 = [git2cpp_path, "commit", "-m", "Second commit"]

subprocess.run(cmd_commit2, capture_output=True, cwd=tmp_path, text=True, check=True)

p3 = tmp_path / "third.txt"

p3.write_text("third file")

cmd_add3 = [git2cpp_path, "add", "third.txt"]

subprocess.run(cmd_add3, capture_output=True, cwd=tmp_path, text=True, check=True)

cmd_commit3 = [git2cpp_path, "commit", "-m", "Third commit"]

subprocess.run(cmd_commit3, capture_output=True, cwd=tmp_path, text=True, check=True)

cmd_log = [git2cpp_path, "log"]

if max_count_flag != "":

cmd_log.append(max_count_flag)

cmd_log.append("2")

p_log = subprocess.run(cmd_log, capture_output=True, cwd=tmp_path, text=True)

assert p_log.returncode == 0

if max_count_flag == "":

assert p_log.stdout.count("Author") > 2

else:

assert p_log.stdout.count("Author") == 2

def test_log_with_head_reference(repo_init_with_commit, commit_env_config, git2cpp_path, tmp_path):

"""Test that HEAD reference is shown on the latest commit."""

assert (tmp_path / "initial.txt").exists()

# Create a new commit

p = tmp_path / "test_file.txt"

p.write_text("test content")

subprocess.run([git2cpp_path, "add", "test_file.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", "test commit"], cwd=tmp_path, check=True)

# Run log with max count 1 to get only the latest commit

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# Check that HEAD reference is shown

assert "HEAD ->" in strip_ansi_colours(p_log.stdout)

assert "master" in p_log.stdout or "main" in p_log.stdout

def test_log_with_tag(commit_env_config, git2cpp_path, tmp_path):

"""Test that tags are shown in log output."""

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

# Create a commit and tag it

p = tmp_path / "tagged_file.txt"

p.write_text("tagged content")

subprocess.run([git2cpp_path, "add", "tagged_file.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", "tagged commit"], cwd=tmp_path, check=True)

# Create a tag (using git command since git2cpp might not have tag creation yet)

subprocess.run([git2cpp_path, "tag", "v1.0.0"], cwd=tmp_path, check=True)

# Run log

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# Check that tag is shown

assert "tag: v1.0.0" in p_log.stdout

def test_log_with_multiple_tags(commit_env_config, git2cpp_path, tmp_path):

"""Test that multiple tags on the same commit are all shown."""

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

# Create a commit

p = tmp_path / "multi_tag_file.txt"

p.write_text("content")

subprocess.run([git2cpp_path, "add", "multi_tag_file.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", "multi tag commit"], cwd=tmp_path, check=True)

# Create multiple tags

subprocess.run([git2cpp_path, "tag", "v1.0.0"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "tag", "stable"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "tag", "latest"], cwd=tmp_path, check=True)

# Run log

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# Check that all tags are shown

assert "tag: v1.0.0" in p_log.stdout

assert "tag: stable" in p_log.stdout

assert "tag: latest" in p_log.stdout

def test_log_with_annotated_tag(commit_env_config, git2cpp_path, tmp_path):

"""Test that annotated tags are shown in log output."""

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

# Create a commit

p = tmp_path / "annotated_tag_file.txt"

p.write_text("content")

subprocess.run([git2cpp_path, "add", "annotated_tag_file.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", "annotated tag commit"], cwd=tmp_path, check=True)

# Create an annotated tag

subprocess.run(

[git2cpp_path, "tag", "-a", "v2.0.0", "-m", "Version 2.0.0"],

cwd=tmp_path,

check=True,

)

# Run log

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# Check that annotated tag is shown

assert "tag: v2.0.0" in p_log.stdout

def test_log_with_branch(commit_env_config, git2cpp_path, tmp_path):

"""Test that branches are shown in log output."""

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

# Create a commit

p = tmp_path / "branch_file.txt"

p.write_text("content")

subprocess.run([git2cpp_path, "add", "branch_file.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", "branch commit"], cwd=tmp_path, check=True)

# Create a new branch pointing to HEAD

subprocess.run([git2cpp_path, "branch", "feature-branch"], cwd=tmp_path, check=True)

# Run log

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# Check that both branches are shown (HEAD -> master/main and feature-branch)

assert "feature-branch" in p_log.stdout

def test_log_with_remote_branches(xtl_clone, commit_env_config, git2cpp_path, tmp_path):

"""Test that remote branches are shown in log output."""

assert (tmp_path / "xtl").exists()

xtl_path = tmp_path / "xtl"

# The xtl_clone fixture already has remote branches (origin/master, etc.)

# Run log to check they appear

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "1"], capture_output=True, cwd=xtl_path, text=True

)

assert p_log.returncode == 0

# Check that origin remote branches are shown

assert "origin/master" in p_log.stdout

def test_log_commit_without_references(commit_env_config, git2cpp_path, tmp_path):

"""Test that commits without any references don't show empty parentheses."""

cmd_init = [git2cpp_path, "init", "."]

p_init = subprocess.run(cmd_init, capture_output=True, cwd=tmp_path)

assert p_init.returncode == 0

# Create two commits - the second one will have refs, the first won't

for i in range(2):

p = tmp_path / f"file_{i}.txt"

p.write_text(f"content {i}")

subprocess.run([git2cpp_path, "add", f"file_{i}.txt"], cwd=tmp_path, check=True)

subprocess.run([git2cpp_path, "commit", "-m", f"commit {i}"], cwd=tmp_path, check=True)

# Run log with 2 commits

p_log = subprocess.run(

[git2cpp_path, "log", "-n", "2"], capture_output=True, cwd=tmp_path, text=True

)

assert p_log.returncode == 0

# First commit line should have references

lines = strip_ansi_colours(p_log.stdout).split("\n")

first_commit_line = [line for line in lines if line.startswith("commit")][0]

assert "(" in first_commit_line # Has references

# Second commit (older one) should not have empty parentheses

second_commit_line = [line for line in lines if line.startswith("commit")][1]

# Should either have no parentheses or have actual references

if "(" in second_commit_line:

# If it has parentheses, they shouldn't be empty

assert "()" not in second_commit_line

@pytest.mark.parametrize("abbrev_commit_flag", ["", "--abbrev-commit", "--no-abbrev-commit"])

@pytest.mark.parametrize("abbrev_flag", ["", "--abbrev=10"])

def test_log_abbrev_commit_flags(

repo_init_with_commit,

commit_env_config,

git2cpp_path,

tmp_path,

abbrev_commit_flag,

abbrev_flag,

):

"""Test for --abbrev-commit, --abbrev=<n> (only applies when --abbrev-commit is set) and --no-abbrev-commit"""

assert (tmp_path / "initial.txt").exists()

cmd = [git2cpp_path, "log", "-n", "1"]

if abbrev_commit_flag != "":

cmd.append(abbrev_commit_flag)

if abbrev_flag != "":

cmd.append(abbrev_flag)

p = subprocess.run(cmd, capture_output=True, cwd=tmp_path, text=True)

assert p.returncode == 0

m = re.search(r"^commit\s+([0-9a-fA-F]+)", strip_ansi_colours(p.stdout), flags=re.MULTILINE)

if abbrev_commit_flag in ["", "--no-abbrev-commit"]:

assert len(m.group(1)) == 40

else:

if abbrev_flag == "--abbrev=10":

assert len(m.group(1)) == 10

else:

assert len(m.group(1)) == 7

def test_log_format_oneline(repo_init_with_commit, git2cpp_path, tmp_path):

"""Test --format=oneline prints the full sha"""

assert (tmp_path / "initial.txt").exists()

p = subprocess.run(

[git2cpp_path, "rev-parse", "HEAD"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

full_sha = p.stdout.strip()

p = subprocess.run(

[git2cpp_path, "log", "--format=oneline", "-n", "1"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

# assert: should contain full 40-hex sha and subject

assert full_sha in p.stdout

assert "Initial commit" in p.stdout

def test_log_oneline(repo_init_with_commit, git2cpp_path, tmp_path):

"""Test --oneline prints the default length sha (i.e 7)"""

assert (tmp_path / "initial.txt").exists()

p = subprocess.run(

[git2cpp_path, "rev-parse", "HEAD"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

full_sha = str(p.stdout.strip())

abbrev7 = full_sha[:7]

subprocess.run([git2cpp_path, "tag", "v1"], capture_output=True, cwd=tmp_path, check=True)

p = subprocess.run(

[git2cpp_path, "log", "--oneline", "-n", "1"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

assert abbrev7 in p.stdout

assert full_sha not in p.stdout

assert "tag: v1" in p.stdout

assert "Initial commit" in p.stdout

def test_log_oneline_no_abbrev_commit(repo_init_with_commit, git2cpp_path, tmp_path):

"""Test --oneline prints prints the full sha when using --no-abbrev-commit"""

assert (tmp_path / "initial.txt").exists()

p = subprocess.run(

[git2cpp_path, "rev-parse", "HEAD"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

full_sha = str(p.stdout.strip())

p = subprocess.run(

[git2cpp_path, "log", "--oneline", "--no-abbrev-commit", "-n", "1"],

cwd=tmp_path,

capture_output=True,

text=True,

)

assert p.returncode == 0

assert full_sha in p.stdout

assert "Initial commit" in p.stdout