gadfly/cmd/gadfly/review_test.go

package main

import (
	"strings"
	"testing"
)

func TestParseDiffNewLines(t *testing.T) {
	diff := "diff --git a/a.go b/a.go\n" +
		"index 111..222 100644\n" +
		"--- a/a.go\n" +
		"+++ b/a.go\n" +
		"@@ -1,3 +1,4 @@\n" +
		" line1\n" +
		"-old2\n" +
		"+new2\n" +
		"+new3\n" +
		" line4\n"
	got := parseDiffNewLines(diff)
	// Only ADDED lines anchor: new2 (line 2) and new3 (line 3). Context lines 1
	// and 4 are walked for counting but not recorded.
	want := map[int]bool{2: true, 3: true}
	if len(got["a.go"]) != len(want) {
		t.Fatalf("a.go lines = %v, want %v (added-only)", got["a.go"], want)
	}
	for ln := range want {
		if !got["a.go"][ln] {
			t.Errorf("expected a.go line %d anchorable", ln)
		}
	}
	if got["a.go"][1] || got["a.go"][4] {
		t.Error("context lines 1/4 should not be anchorable (added-only)")
	}
}

func TestParseDiffNewLinesContentLooksLikeHeader(t *testing.T) {
	// An added line whose CONTENT is "++ weird" appears as "+++ weird" in the
	// diff. Hunk-length tracking must read it as content, not a file header.
	diff := "--- a/x\n+++ b/x\n@@ -1,1 +1,2 @@\n ctx\n+++ weird\n"
	got := parseDiffNewLines(diff)
	if got["x"][1] { // context line, not recorded (added-only)
		t.Errorf("line 1 is context, should not anchor: %v", got["x"])
	}
	if !got["x"][2] { // the "+++ weird" added line
		t.Errorf("want added line 2 anchorable, got %v", got["x"])
	}
}

func TestAnchorLineScansSpan(t *testing.T) {
	// A cluster spanning 10..14 whose min line (10) isn't in the diff but whose
	// span includes added line 14 must anchor to 14, not be dropped.
	added := map[string]map[int]bool{"a.go": {14: true}}
	clusters := []cluster{{file: "a.go", line: 10, maxLine: 14, severity: "high", title: "t", models: set("m1"), lenses: set("x")}}
	cs := inlineComments(clusters, added)
	if len(cs) != 1 || cs[0].NewPosition != 14 {
		t.Fatalf("want anchor at 14 via span scan, got %+v", cs)
	}
}

func TestParseDiffNewLinesMultiFile(t *testing.T) {
	diff := "diff --git a/one.go b/one.go\n--- a/one.go\n+++ b/one.go\n@@ -0,0 +1,2 @@\n+a\n+b\n" +
		"diff --git a/two.go b/two.go\n--- a/two.go\n+++ b/two.go\n@@ -5,0 +6,1 @@\n+c\n"
	got := parseDiffNewLines(diff)
	if !got["one.go"][1] || !got["one.go"][2] {
		t.Errorf("one.go: want 1,2 got %v", got["one.go"])
	}
	if !got["two.go"][6] {
		t.Errorf("two.go: want 6 got %v", got["two.go"])
	}
}

func TestInlineCommentsNormalizesPaths(t *testing.T) {
	// Diff path "b/pkg/x.go" -> "pkg/x.go"; a finding written as "./pkg/x.go" must
	// still anchor (both normalize to the same repo-relative path).
	addable := parseDiffNewLines("--- a/pkg/x.go\n+++ b/pkg/x.go\n@@ -0,0 +1,1 @@\n+bug\n")
	clusters := []cluster{{file: "./pkg/x.go", line: 1, severity: "high", title: "t", models: set("m1"), lenses: set("x")}}
	if cs := inlineComments(clusters, addable); len(cs) != 1 || cs[0].Path != "pkg/x.go" {
		t.Errorf("path normalization failed to anchor: %+v", cs)
	}
}

func TestInlineCommentsFiltersToDiffLines(t *testing.T) {
	addable := map[string]map[int]bool{"a.go": {10: true, 11: true}}
	clusters := []cluster{
		{file: "a.go", line: 10, severity: "high", title: "anchored", models: set("m1", "m2"), lenses: set("security"), detail: "d"},
		{file: "a.go", line: 99, severity: "high", title: "off-diff line", models: set("m1"), lenses: set("security")},
		{file: "b.go", line: 1, severity: "high", title: "off-diff file", models: set("m1"), lenses: set("security")},
	}
	cs := inlineComments(clusters, addable)
	if len(cs) != 1 {
		t.Fatalf("want 1 anchorable inline comment, got %d", len(cs))
	}
	if cs[0].Path != "a.go" || cs[0].NewPosition != 10 {
		t.Errorf("wrong anchor: %+v", cs[0])
	}
	if !strings.Contains(cs[0].Body, "anchored") || !strings.Contains(cs[0].Body, "2 model") {
		t.Errorf("inline body missing title/agreement: %q", cs[0].Body)
	}
}

func set(xs ...string) map[string]bool {
	m := map[string]bool{}
	for _, x := range xs {
		m[x] = true
	}
	return m
}