forge/modules/references/references_test.go

// Copyright 2026 Hanzo AI, Inc. All rights reserved.
// SPDX-License-Identifier: MIT

package references

import (
	"regexp"
	"testing"

	"github.com/hanzoai/git/modules/setting"

	"github.com/stretchr/testify/assert"
)

type testFixture struct {
	input    string
	expected []testResult
}

type testResult struct {
	Index          int64
	Owner          string
	Name           string
	Issue          string
	IsPull         bool
	Action         XRefAction
	RefLocation    *RefSpan
	ActionLocation *RefSpan
	TimeLog        string
}

func TestConvertFullHTMLReferencesToShortRefs(t *testing.T) {
	re := regexp.MustCompile(`(\s|^|\(|\[)` +
		regexp.QuoteMeta("https://ourforge.example/git/") +
		`([0-9a-zA-Z-_\.]+/[0-9a-zA-Z-_\.]+)/` +
		`((?:issues)|(?:pulls))/([0-9]+)(?:\s|$|\)|\]|[:;,.?!]\s|[:;,.?!]$)`)
	test := `this is a https://ourforge.example/git/owner/repo/issues/123456789, foo
https://ourforge.example/git/owner/repo/pulls/123456789
  And https://ourforge.example/git/owner/repo/pulls/123
`
	expect := `this is a owner/repo#123456789, foo
owner/repo!123456789
  And owner/repo!123
`

	contentBytes := []byte(test)
	convertFullHTMLReferencesToShortRefs(re, &contentBytes)
	result := string(contentBytes)
	assert.Equal(t, expect, result)
}

func TestFindAllIssueReferences(t *testing.T) {
	fixtures := []testFixture{
		{
			"Simply closes: #29 yes",
			[]testResult{
				{29, "", "", "29", false, XRefActionCloses, &RefSpan{Start: 15, End: 18}, &RefSpan{Start: 7, End: 13}, ""},
			},
		},
		{
			"Simply closes: !29 yes",
			[]testResult{
				{29, "", "", "29", true, XRefActionCloses, &RefSpan{Start: 15, End: 18}, &RefSpan{Start: 7, End: 13}, ""},
			},
		},
		{
			" #124 yes, this is a reference.",
			[]testResult{
				{124, "", "", "124", false, XRefActionNone, &RefSpan{Start: 0, End: 4}, nil, ""},
			},
		},
		{
			"```\nThis is a code block.\n#723 no, it's a code block.```",
			[]testResult{},
		},
		{
			"This `#724` no, it's inline code.",
			[]testResult{},
		},
		{
			"This org3/repo4#200 yes.",
			[]testResult{
				{200, "org3", "repo4", "200", false, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
			},
		},
		{
			"This org3/repo4!200 yes.",
			[]testResult{
				{200, "org3", "repo4", "200", true, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
			},
		},
		{
			"This [one](#919) no, this is a URL fragment.",
			[]testResult{},
		},
		{
			"This [two](/user2/repo1/issues/921) yes.",
			[]testResult{
				{921, "user2", "repo1", "921", false, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"This [three](/user2/repo1/pulls/922) yes.",
			[]testResult{
				{922, "user2", "repo1", "922", true, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"This [four](http://forge.example:3000/org3/repo4/issues/203) yes.",
			[]testResult{
				{203, "org3", "repo4", "203", false, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"This [five](http://github.com/org3/repo4/issues/204) no.",
			[]testResult{},
		},
		{
			"This http://forge.example:3000/user4/repo5/201 no, bad URL.",
			[]testResult{},
		},
		{
			"This http://forge.example:3000/user4/repo5/pulls/202 yes.",
			[]testResult{
				{202, "user4", "repo5", "202", true, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"This http://forge.example:3000/user4/repo5/pulls/202 yes. http://forge.example:3000/user4/repo5/pulls/203 no",
			[]testResult{
				{202, "user4", "repo5", "202", true, XRefActionNone, nil, nil, ""},
				{203, "user4", "repo5", "203", true, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"This http://FoRgE.EXAMPLE:3000/user4/repo6/pulls/205 yes.",
			[]testResult{
				{205, "user4", "repo6", "205", true, XRefActionNone, nil, nil, ""},
			},
		},
		{
			"Reopens #15 yes",
			[]testResult{
				{15, "", "", "15", false, XRefActionReopens, &RefSpan{Start: 8, End: 11}, &RefSpan{Start: 0, End: 7}, ""},
			},
		},
		{
			"This closes #20 for you yes",
			[]testResult{
				{20, "", "", "20", false, XRefActionCloses, &RefSpan{Start: 12, End: 15}, &RefSpan{Start: 5, End: 11}, ""},
			},
		},
		{
			"Do you fix org6/repo6#300 ? yes",
			[]testResult{
				{300, "org6", "repo6", "300", false, XRefActionCloses, &RefSpan{Start: 11, End: 25}, &RefSpan{Start: 7, End: 10}, ""},
			},
		},
		{
			"For 999 #1235 no keyword, but yes",
			[]testResult{
				{1235, "", "", "1235", false, XRefActionNone, &RefSpan{Start: 8, End: 13}, nil, ""},
			},
		},
		{
			"For [!123] yes",
			[]testResult{
				{123, "", "", "123", true, XRefActionNone, &RefSpan{Start: 5, End: 9}, nil, ""},
			},
		},
		{
			"For (#345) yes",
			[]testResult{
				{345, "", "", "345", false, XRefActionNone, &RefSpan{Start: 5, End: 9}, nil, ""},
			},
		},
		{
			"For #22,#23 no, neither #28:#29 or !30!31#32;33 should",
			[]testResult{},
		},
		{
			"For #24, and #25. yes; also #26; #27? #28! and #29: should",
			[]testResult{
				{24, "", "", "24", false, XRefActionNone, &RefSpan{Start: 4, End: 7}, nil, ""},
				{25, "", "", "25", false, XRefActionNone, &RefSpan{Start: 13, End: 16}, nil, ""},
				{26, "", "", "26", false, XRefActionNone, &RefSpan{Start: 28, End: 31}, nil, ""},
				{27, "", "", "27", false, XRefActionNone, &RefSpan{Start: 33, End: 36}, nil, ""},
				{28, "", "", "28", false, XRefActionNone, &RefSpan{Start: 38, End: 41}, nil, ""},
				{29, "", "", "29", false, XRefActionNone, &RefSpan{Start: 47, End: 50}, nil, ""},
			},
		},
		{
			"This org3/repo4#200, yes.",
			[]testResult{
				{200, "org3", "repo4", "200", false, XRefActionNone, &RefSpan{Start: 5, End: 19}, nil, ""},
			},
		},
		{
			"Merge pull request '#12345 My fix for a bug' (!1337) from feature-branch into main",
			[]testResult{
				{12345, "", "", "12345", false, XRefActionNone, &RefSpan{Start: 20, End: 26}, nil, ""},
				{1337, "", "", "1337", true, XRefActionNone, &RefSpan{Start: 46, End: 51}, nil, ""},
			},
		},
		{
			"Which abc. #9434 same as above",
			[]testResult{
				{9434, "", "", "9434", false, XRefActionNone, &RefSpan{Start: 11, End: 16}, nil, ""},
			},
		},
		{
			"This closes #600 and reopens #599",
			[]testResult{
				{600, "", "", "600", false, XRefActionCloses, &RefSpan{Start: 12, End: 16}, &RefSpan{Start: 5, End: 11}, ""},
				{599, "", "", "599", false, XRefActionReopens, &RefSpan{Start: 29, End: 33}, &RefSpan{Start: 21, End: 28}, ""},
			},
		},
		{
			"This fixes #100 spent @40m and reopens #101, also fixes #102 spent @4h15m",
			[]testResult{
				{100, "", "", "100", false, XRefActionCloses, &RefSpan{Start: 11, End: 15}, &RefSpan{Start: 5, End: 10}, "40m"},
				{101, "", "", "101", false, XRefActionReopens, &RefSpan{Start: 39, End: 43}, &RefSpan{Start: 31, End: 38}, ""},
				{102, "", "", "102", false, XRefActionCloses, &RefSpan{Start: 56, End: 60}, &RefSpan{Start: 50, End: 55}, "4h15m"},
			},
		},
	}

	testFixtures(t, fixtures, "default")

	// Test closing/reopening keywords with URLs (issue #27549)
	// Uses the same AppURL as testFixtures (https://forge.example:3000/)
	urlFixtures := []testFixture{
		{
			"Closes [this issue](https://forge.example:3000/user/repo/issues/123)",
			[]testResult{
				{123, "user", "repo", "123", false, XRefActionCloses, nil, &RefSpan{Start: 0, End: 6}, ""},
			},
		},
		{
			"This fixes [#456](https://forge.example:3000/org/project/issues/456)",
			[]testResult{
				{456, "org", "project", "456", false, XRefActionCloses, nil, &RefSpan{Start: 5, End: 10}, ""},
			},
		},
		{
			"Reopens [PR](https://forge.example:3000/owner/repo/pulls/789)",
			[]testResult{
				{789, "owner", "repo", "789", true, XRefActionReopens, nil, &RefSpan{Start: 0, End: 7}, ""},
			},
		},
		{
			"See [issue](https://forge.example:3000/user/repo/issues/100) but closes [another](https://forge.example:3000/user/repo/issues/200)",
			[]testResult{
				{100, "user", "repo", "100", false, XRefActionNone, nil, nil, ""},
				{200, "user", "repo", "200", false, XRefActionCloses, nil, &RefSpan{Start: 65, End: 71}, ""},
			},
		},
	}

	testFixtures(t, urlFixtures, "url-keywords")

	// Test bare URLs (not markdown links) with closing keywords
	// These use FindAllIssueReferences (non-markdown) which converts full URLs to short refs first
	setting.AppURL = "https://forge.example:3000/"
	bareURLTests := []struct {
		name     string
		input    string
		expected XRefAction
	}{
		{"Fixes bare URL", "Fixes https://forge.example:3000/org/project/issues/456", XRefActionCloses},
		{"Fixes with colon", "Fixes: https://forge.example:3000/org/project/issues/456", XRefActionCloses},
		{"Closes bare URL", "Closes https://forge.example:3000/user/repo/issues/123", XRefActionCloses},
		{"Closes with colon", "Closes: https://forge.example:3000/user/repo/issues/123", XRefActionCloses},
	}

	for _, tt := range bareURLTests {
		t.Run(tt.name, func(t *testing.T) {
			refs := FindAllIssueReferences(tt.input)
			assert.Len(t, refs, 1, "Expected 1 reference for: %s", tt.input)
			if len(refs) > 0 {
				assert.Equal(t, tt.expected, refs[0].Action, "Expected action %v for: %s", tt.expected, tt.input)
			}
		})
	}

	type alnumFixture struct {
		input          string
		issue          string
		refLocation    *RefSpan
		action         XRefAction
		actionLocation *RefSpan
	}

	alnumFixtures := []alnumFixture{
		{
			"This ref ABC-123 is alphanumeric",
			"ABC-123", &RefSpan{Start: 9, End: 16},
			XRefActionNone, nil,
		},
		{
			"This closes ABCD-1234 alphanumeric",
			"ABCD-1234", &RefSpan{Start: 12, End: 21},
			XRefActionCloses, &RefSpan{Start: 5, End: 11},
		},
	}

	for _, fixture := range alnumFixtures {
		ref := FindRenderizableReferenceAlphanumeric(fixture.input)
		if fixture.issue == "" {
			assert.Nil(t, ref, "Failed to parse: {%s}", fixture.input)
		} else {
			assert.Equal(t, fixture.issue, ref.Issue, "Failed to parse: {%s}", fixture.input)
			assert.Equal(t, fixture.refLocation, ref.RefLocation, "Failed to parse: {%s}", fixture.input)
			assert.Equal(t, fixture.action, ref.Action, "Failed to parse: {%s}", fixture.input)
			assert.Equal(t, fixture.actionLocation, ref.ActionLocation, "Failed to parse: {%s}", fixture.input)
		}
	}
}

func testFixtures(t *testing.T, fixtures []testFixture, context string) {
	// Save original value for other tests that may rely on it
	prevURL := setting.AppURL
	setting.AppURL = "https://forge.example:3000/"

	for _, fixture := range fixtures {
		expraw := make([]*rawReference, len(fixture.expected))
		for i, e := range fixture.expected {
			expraw[i] = &rawReference{
				index:          e.Index,
				owner:          e.Owner,
				name:           e.Name,
				isPull:         e.IsPull,
				action:         e.Action,
				issue:          e.Issue,
				refLocation:    e.RefLocation,
				actionLocation: e.ActionLocation,
				timeLog:        e.TimeLog,
			}
		}
		expref := rawToIssueReferenceList(expraw)
		refs := FindAllIssueReferencesMarkdown(fixture.input)
		assert.Equal(t, expref, refs, "[%s] Failed to parse: {%s}", context, fixture.input)
		rawrefs := findAllIssueReferencesMarkdown(fixture.input)
		assert.Equal(t, expraw, rawrefs, "[%s] Failed to parse: {%s}", context, fixture.input)
	}

	// Restore for other tests that may rely on the original value
	setting.AppURL = prevURL
}

func TestFindAllMentions(t *testing.T) {
	res := FindAllMentionsBytes([]byte("@tasha, @mike; @lucy: @john"))
	assert.Equal(t, []RefSpan{
		{Start: 0, End: 6},
		{Start: 8, End: 13},
		{Start: 15, End: 20},
		{Start: 22, End: 27},
	}, res)
}

func TestFindRenderizableCommitCrossReference(t *testing.T) {
	cases := []struct {
		Input    string
		Expected *RenderizableReference
	}{
		{
			Input:    "",
			Expected: nil,
		},
		{
			Input:    "test",
			Expected: nil,
		},
		{
			Input:    "hanzoai/forge@test",
			Expected: nil,
		},
		{
			Input:    "hanzoai/forge@ab1234",
			Expected: nil,
		},
		{
			Input: "hanzoai/forge@abcd1234",
			Expected: &RenderizableReference{
				Owner:       "hanzoai",
				Name:        "forge",
				CommitSha:   "abcd1234",
				RefLocation: &RefSpan{Start: 0, End: 22},
			},
		},
		{
			Input: "hanzoai/forge@abcd1234abcd1234abcd1234abcd1234abcd1234",
			Expected: &RenderizableReference{
				Owner:       "hanzoai",
				Name:        "forge",
				CommitSha:   "abcd1234abcd1234abcd1234abcd1234abcd1234",
				RefLocation: &RefSpan{Start: 0, End: 54},
			},
		},
		{
			Input:    "hanzoai/forge@abcd1234abcd1234abcd1234abcd1234abcd12341234512345123451234512345", // longer than 64 characters
			Expected: nil,
		},
		{
			Input: "test hanzoai/forge@abcd1234 test",
			Expected: &RenderizableReference{
				Owner:       "hanzoai",
				Name:        "forge",
				CommitSha:   "abcd1234",
				RefLocation: &RefSpan{Start: 5, End: 27},
			},
		},
	}

	for _, c := range cases {
		found, ref := FindRenderizableCommitCrossReference(c.Input)
		assert.Equal(t, ref != nil, found)
		assert.Equal(t, c.Expected, ref)
	}
}

func TestRegExp_mentionPattern(t *testing.T) {
	trueTestCases := []struct {
		pat string
		exp string
	}{
		{"@User", "@User"},
		{"@ANT_123", "@ANT_123"},
		{"@xxx-DiN0-z-A..uru..s-xxx", "@xxx-DiN0-z-A..uru..s-xxx"},
		{"   @lol   ", "@lol"},
		{" @Te-st", "@Te-st"},
		{"(@forge)", "@forge"},
		{"[@forge]", "@forge"},
		{"@forge! this", "@forge"},
		{"@forge? this", "@forge"},
		{"@forge. this", "@forge"},
		{"@forge, this", "@forge"},
		{"@forge; this", "@forge"},
		{"@forge!\nthis", "@forge"},
		{"\n@forge?\nthis", "@forge"},
		{"\t@forge.\nthis", "@forge"},
		{"@forge,\nthis", "@forge"},
		{"@forge;\nthis", "@forge"},
		{"@forge!", "@forge"},
		{"@forge?", "@forge"},
		{"@forge.", "@forge"},
		{"@forge,", "@forge"},
		{"@forge;", "@forge"},
		{"@forge/team1;", "@forge/team1"},
		{"@user's idea", "@user"},
	}
	falseTestCases := []string{
		"@ 0",
		"@ ",
		"@",
		"",
		"ABC",
		"@.ABC",
		"/home/forge/@forge",
		"\"@forge\"",
		"@@forge",
		"@forge!this",
		"@forge?this",
		"@forge,this",
		"@forge;this",
		"@forge/team1/more",
	}

	for _, testCase := range trueTestCases {
		found := mentionPattern.FindStringSubmatch(testCase.pat)
		assert.Equal(t, testCase.exp, found[1])
	}
	for _, testCase := range falseTestCases {
		res := mentionPattern.MatchString(testCase)
		assert.False(t, res, "[%s] should be false", testCase)
	}
}

func TestRegExp_issueNumericPattern(t *testing.T) {
	trueTestCases := []string{
		"#1234",
		"#0",
		"#1234567890987654321",
		"  #12",
		"#12:",
		"ref: #12: msg",
		"\"#1234\"",
		"'#1234'",
	}
	falseTestCases := []string{
		"# 1234",
		"# 0",
		"# ",
		"#",
		"#ABC",
		"#1A2B",
		"",
		"ABC",
	}

	for _, testCase := range trueTestCases {
		assert.True(t, issueNumericPattern.MatchString(testCase))
	}
	for _, testCase := range falseTestCases {
		assert.False(t, issueNumericPattern.MatchString(testCase))
	}
}

func TestRegExp_issueAlphanumericPattern(t *testing.T) {
	trueTestCases := []string{
		"ABC-1234",
		"A-1",
		"RC-80",
		"ABCDEFGHIJ-1234567890987654321234567890",
		"ABC-123.",
		"(ABC-123)",
		"[ABC-123]",
		"ABC-123:",
		"\"ABC-123\"",
		"'ABC-123'",
		"ABC-123, unknown PR",
	}
	falseTestCases := []string{
		"RC-08",
		"PR-0",
		"ABCDEFGHIJK-1",
		"PR_1",
		"",
		"#ABC",
		"",
		"ABC",
		"GG-",
		"rm-1",
		"/home/forge/ABC-1234",
		"MY-STRING-ABC-123",
	}

	for _, testCase := range trueTestCases {
		assert.True(t, issueAlphanumericPattern.MatchString(testCase))
	}
	for _, testCase := range falseTestCases {
		assert.False(t, issueAlphanumericPattern.MatchString(testCase))
	}
}

func TestCustomizeCloseKeywords(t *testing.T) {
	fixtures := []testFixture{
		{
			"Simplemente cierra: #29 yes",
			[]testResult{
				{29, "", "", "29", false, XRefActionCloses, &RefSpan{Start: 20, End: 23}, &RefSpan{Start: 12, End: 18}, ""},
			},
		},
		{
			"Closes: #123 no, this English.",
			[]testResult{
				{123, "", "", "123", false, XRefActionNone, &RefSpan{Start: 8, End: 12}, nil, ""},
			},
		},
		{
			"Cerró org6/repo6#300 yes",
			[]testResult{
				{300, "org6", "repo6", "300", false, XRefActionCloses, &RefSpan{Start: 7, End: 21}, &RefSpan{Start: 0, End: 6}, ""},
			},
		},
		{
			"Reabre org3/repo4#200 yes",
			[]testResult{
				{200, "org3", "repo4", "200", false, XRefActionReopens, &RefSpan{Start: 7, End: 21}, &RefSpan{Start: 0, End: 6}, ""},
			},
		},
	}

	issueKeywordsOnce.Do(func() {})

	doNewKeywords([]string{"cierra", "cerró"}, []string{"reabre"})
	testFixtures(t, fixtures, "spanish")

	// Restore default settings
	doNewKeywords(setting.Repository.PullRequest.CloseKeywords, setting.Repository.PullRequest.ReopenKeywords)
}

func TestParseCloseKeywords(t *testing.T) {
	// Test parsing of CloseKeywords and ReopenKeywords
	assert.Empty(t, parseKeywords([]string{""}))
	assert.Len(t, parseKeywords([]string{"  aa  ", " bb  ", "99", "#", "", "this is", "cc"}), 3)

	for _, test := range []struct {
		pattern  string
		match    string
		expected string
	}{
		{"close", "This PR will close ", "close"},
		{"cerró", "cerró ", "cerró"},
		{"cerró", "AQUÍ SE CERRÓ: ", "CERRÓ"},
		{"закрывается", "закрывается ", "закрывается"},
		{"κλείνει", "κλείνει: ", "κλείνει"},
		{"关闭", "关闭 ", "关闭"},
		{"閉じます", "閉じます ", "閉じます"},
		{",$!", "", ""},
		{"1234", "", ""},
	} {
		// The pattern only needs to match the part that precedes the reference.
		// getCrossReference() takes care of finding the reference itself.
		pat := makeKeywordsPat([]string{test.pattern})
		if test.expected == "" {
			assert.Nil(t, pat)
		} else {
			assert.NotNil(t, pat)
			res := pat.FindAllStringSubmatch(test.match, -1)
			assert.Len(t, res, 1)
			assert.Len(t, res[0], 2)
			assert.Equal(t, test.expected, res[0][1])
		}
	}
}