//go:build cgo package utils import ( "context" "crypto/rand" "encoding/hex" "fmt" "testing" "github.com/steveyegge/beads/internal/storage/dolt" "github.com/steveyegge/beads/internal/testutil" "github.com/steveyegge/beads/internal/types" ) func newTestStore(t *testing.T) *dolt.DoltStore { t.Helper() testutil.RequireDoltBinary(t) if testServerPort == 0 { t.Skip("Test Dolt server not running, skipping test") } ctx := context.Background() dbName := uniqueTestDBName(t) store, err := dolt.New(ctx, &dolt.Config{ Path: t.TempDir(), Database: dbName, ServerPort: testServerPort, CreateIfMissing: true, // test creates fresh database }) if err != nil { t.Fatalf("Failed to create dolt store: %v", err) } if err := store.SetConfig(ctx, "issue_prefix", "bd"); err != nil { store.Close() t.Fatalf("Failed to set issue_prefix: %v", err) } t.Cleanup(func() { store.Close() }) return store } func uniqueTestDBName(t *testing.T) string { t.Helper() buf := make([]byte, 6) if _, err := rand.Read(buf); err != nil { t.Fatalf("failed to generate random bytes: %v", err) } return fmt.Sprintf("testdb_%s", hex.EncodeToString(buf)) } func TestParseIssueID(t *testing.T) { tests := []struct { name string input string prefix string expected string }{ { name: "already has prefix", input: "bd-a3f8e9", prefix: "bd-", expected: "bd-a3f8e9", }, { name: "missing prefix", input: "a3f8e9", prefix: "bd-", expected: "bd-a3f8e9", }, { name: "hierarchical with prefix", input: "bd-a3f8e9.1.2", prefix: "bd-", expected: "bd-a3f8e9.1.2", }, { name: "hierarchical without prefix", input: "a3f8e9.1.2", prefix: "bd-", expected: "bd-a3f8e9.1.2", }, { name: "custom prefix with ID", input: "ticket-123", prefix: "ticket-", expected: "ticket-123", }, { name: "custom prefix without ID", input: "123", prefix: "ticket-", expected: "ticket-123", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := parseIssueID(tt.input, tt.prefix) if result != tt.expected { t.Errorf("parseIssueID(%q, %q) = %q; want %q", tt.input, tt.prefix, result, tt.expected) } }) } } func TestResolvePartialID(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create test issues with sequential IDs (current implementation) // When hash IDs (bd-165) are implemented, these can be hash-based issue1 := &types.Issue{ ID: "bd-1", Title: "Test Issue 1", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } issue2 := &types.Issue{ ID: "bd-2", Title: "Test Issue 2", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } issue3 := &types.Issue{ ID: "bd-10", Title: "Test Issue 3", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } // Test hierarchical IDs - parent and child parentIssue := &types.Issue{ ID: "offlinebrew-3d0", Title: "Parent Epic", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeEpic, } childIssue := &types.Issue{ ID: "offlinebrew-3d0.1", Title: "Child Task", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, issue1, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, issue2, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, issue3, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, parentIssue, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, childIssue, "test"); err != nil { t.Fatal(err) } // Set config for prefix if err := store.SetConfig(ctx, "issue_prefix", "bd-"); err != nil { t.Fatal(err) } tests := []struct { name string input string expected string shouldError bool errorMsg string }{ { name: "exact match with prefix", input: "bd-1", expected: "bd-1", }, { name: "exact match without prefix", input: "1", expected: "bd-1", }, { name: "exact match with prefix (two digits)", input: "bd-10", expected: "bd-10", }, { name: "exact match without prefix (two digits)", input: "10", expected: "bd-10", }, { name: "nonexistent issue", input: "bd-999", shouldError: true, errorMsg: "no issue found", }, { name: "partial match - unique substring", input: "bd-1", expected: "bd-1", }, { name: "ambiguous partial match", input: "bd-1", expected: "bd-1", // Will match exactly, not ambiguously }, { name: "exact match parent ID with hierarchical child - gh-316", input: "offlinebrew-3d0", expected: "offlinebrew-3d0", // Should match exactly, not be ambiguous with offlinebrew-3d0.1 }, { name: "exact match parent without prefix - gh-316", input: "3d0", expected: "offlinebrew-3d0", // Should still prefer exact hash match }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ResolvePartialID(ctx, store, tt.input) if tt.shouldError { if err == nil { t.Errorf("ResolvePartialID(%q) expected error containing %q, got nil", tt.input, tt.errorMsg) } else if tt.errorMsg != "" && !contains(err.Error(), tt.errorMsg) { t.Errorf("ResolvePartialID(%q) error = %q; want error containing %q", tt.input, err.Error(), tt.errorMsg) } } else { if err != nil { t.Errorf("ResolvePartialID(%q) unexpected error: %v", tt.input, err) } if result != tt.expected { t.Errorf("ResolvePartialID(%q) = %q; want %q", tt.input, result, tt.expected) } } }) } } func TestResolvePartialIDs(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create test issues issue1 := &types.Issue{ ID: "bd-1", Title: "Test Issue 1", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } issue2 := &types.Issue{ ID: "bd-2", Title: "Test Issue 2", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, issue1, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, issue2, "test"); err != nil { t.Fatal(err) } if err := store.SetConfig(ctx, "issue_prefix", "bd-"); err != nil { t.Fatal(err) } tests := []struct { name string inputs []string expected []string shouldError bool }{ { name: "resolve multiple IDs without prefix", inputs: []string{"1", "2"}, expected: []string{"bd-1", "bd-2"}, }, { name: "resolve mixed full and partial IDs", inputs: []string{"bd-1", "2"}, expected: []string{"bd-1", "bd-2"}, }, { name: "error on nonexistent ID", inputs: []string{"1", "999"}, shouldError: true, }, { name: "empty input list", inputs: []string{}, expected: []string{}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ResolvePartialIDs(ctx, store, tt.inputs) if tt.shouldError { if err == nil { t.Errorf("ResolvePartialIDs(%v) expected error, got nil", tt.inputs) } } else { if err != nil { t.Errorf("ResolvePartialIDs(%v) unexpected error: %v", tt.inputs, err) } if len(result) != len(tt.expected) { t.Errorf("ResolvePartialIDs(%v) returned %d results; want %d", tt.inputs, len(result), len(tt.expected)) } for i := range result { if result[i] != tt.expected[i] { t.Errorf("ResolvePartialIDs(%v)[%d] = %q; want %q", tt.inputs, i, result[i], tt.expected[i]) } } } }) } } func TestResolvePartialID_NoConfig(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create test issue without setting config (test default prefix) issue1 := &types.Issue{ ID: "bd-1", Title: "Test Issue", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, issue1, "test"); err != nil { t.Fatal(err) } // Don't set config - should use default "bd" prefix result, err := ResolvePartialID(ctx, store, "1") if err != nil { t.Fatalf("ResolvePartialID failed with default config: %v", err) } if result != "bd-1" { t.Errorf("ResolvePartialID(\"1\") with default config = %q; want \"bd-1\"", result) } } func TestResolvePartialID_NilStorage(t *testing.T) { ctx := context.Background() // Test that nil storage returns an error instead of panicking _, err := ResolvePartialID(ctx, nil, "bd-123") if err == nil { t.Fatal("ResolvePartialID with nil storage should return error, got nil") } expectedMsg := "storage is nil" if !contains(err.Error(), expectedMsg) { t.Errorf("ResolvePartialID error = %q; want error containing %q", err.Error(), expectedMsg) } } func TestExtractIssuePrefix(t *testing.T) { tests := []struct { name string issueID string expected string }{ { name: "standard format", issueID: "bd-a3f8e9", expected: "bd", }, { name: "custom prefix", issueID: "ticket-123", expected: "ticket", }, { name: "hierarchical ID", issueID: "bd-a3f8e9.1.2", expected: "bd", }, { name: "no hyphen", issueID: "invalid", expected: "", }, { name: "empty string", issueID: "", expected: "", }, { name: "only prefix", issueID: "bd-", expected: "bd", }, { name: "multi-part prefix with numeric suffix", issueID: "alpha-beta-1", expected: "alpha-beta", // Last hyphen before numeric suffix }, { name: "multi-part non-numeric suffix (word-like)", issueID: "vc-baseline-test", expected: "vc", // Word-like suffix (4+ chars, no digit) uses first hyphen (bd-fasa fix) }, { name: "beads-vscode style prefix", issueID: "beads-vscode-1", expected: "beads-vscode", // Last hyphen before numeric suffix }, { name: "web-app style prefix", issueID: "web-app-123", expected: "web-app", // Should extract "web-app", not "web-" }, { name: "three-part prefix with hash", issueID: "my-cool-app-a3f8e9", expected: "my-cool-app", // Hash suffix should use last hyphen logic }, { name: "four-part prefix with 4-char hash", issueID: "super-long-project-name-1a2b", expected: "super-long-project-name", // 4-char hash }, { name: "prefix with 5-char hash", issueID: "my-app-1a2b3", expected: "my-app", // 5-char hash }, { name: "prefix with 6-char hash", issueID: "web-app-a1b2c3", expected: "web-app", // 6-char hash }, { name: "uppercase hash", issueID: "my-app-A3F8E9", expected: "my-app", // Uppercase hash should work }, { name: "mixed case hash", issueID: "proj-AbCd12", expected: "proj", // Mixed case hash should work }, { name: "3-char hash with hyphenated prefix", issueID: "document-intelligence-0sa", expected: "document-intelligence", // 3-char hash (base36) should use last hyphen }, { name: "3-char hash with multi-part prefix", issueID: "my-cool-app-1x7", expected: "my-cool-app", // 3-char base36 hash }, { name: "3-char all-letters suffix (now treated as hash, GH #446)", issueID: "test-proj-abc", expected: "test-proj", // 3-char all-letter now accepted as hash (GH #446) }, // GH#405: multi-hyphen prefixes with hash suffixes { name: "hacker-news prefix with hash (GH#405)", issueID: "hacker-news-ko4", expected: "hacker-news", // Not "hacker" - 3-char hash uses last hyphen }, { name: "hacker-news prefix with numeric suffix (GH#405)", issueID: "hacker-news-42", expected: "hacker-news", // Numeric suffix uses last hyphen }, { name: "me-py-toolkit prefix with hash (GH#405)", issueID: "me-py-toolkit-a1b", expected: "me-py-toolkit", // 3-part prefix, 3-char hash }, { name: "me-py-toolkit prefix with 4-char hash (GH#405)", issueID: "me-py-toolkit-1a2b", expected: "me-py-toolkit", // 3-part prefix, 4-char hash with digits }, { name: "me-py-toolkit prefix with numeric suffix (GH#405)", issueID: "me-py-toolkit-7", expected: "me-py-toolkit", // 3-part prefix, numeric suffix }, { name: "three-hyphen prefix with 3-char all-letter hash", issueID: "my-cool-web-app-bat", expected: "my-cool-web-app", // 4-part prefix, 3-char all-letter hash }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := ExtractIssuePrefix(tt.issueID) if result != tt.expected { t.Errorf("ExtractIssuePrefix(%q) = %q; want %q", tt.issueID, result, tt.expected) } }) } } func TestExtractIssuePrefixKnown(t *testing.T) { tests := []struct { name string issueID string knownPrefixes []string expected string }{ { name: "known prefix matches multi-dash", issueID: "me-py-toolkit-abcd", knownPrefixes: []string{"me-py-toolkit"}, expected: "me-py-toolkit", }, { name: "overlapping prefixes: longest wins", issueID: "hq-cv-test", knownPrefixes: []string{"hq", "hq-cv"}, expected: "hq-cv", }, { name: "overlapping prefixes reversed order: longest still wins", issueID: "hq-cv-test", knownPrefixes: []string{"hq-cv", "hq"}, expected: "hq-cv", }, { name: "no known prefix: falls back to heuristic", issueID: "vc-baseline-test", knownPrefixes: []string{"bd"}, expected: "vc", // heuristic: word-like suffix falls back to first hyphen }, { name: "known prefix with trailing hyphen is normalized", issueID: "hacker-news-ko4", knownPrefixes: []string{"hacker-news-"}, expected: "hacker-news", }, { name: "known prefix with whitespace is normalized", issueID: "hacker-news-ko4", knownPrefixes: []string{" hacker-news "}, expected: "hacker-news", }, { name: "empty known prefixes: falls back to heuristic", issueID: "bd-a3f8e9", knownPrefixes: nil, expected: "bd", // heuristic result }, { name: "simple known prefix", issueID: "bd-a3f8e9", knownPrefixes: []string{"bd"}, expected: "bd", }, { name: "known prefix among several", issueID: "hacker-news-ko4", knownPrefixes: []string{"bd", "gt", "hacker-news"}, expected: "hacker-news", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := ExtractIssuePrefixKnown(tt.issueID, tt.knownPrefixes) if result != tt.expected { t.Errorf("ExtractIssuePrefixKnown(%q, %v) = %q; want %q", tt.issueID, tt.knownPrefixes, result, tt.expected) } }) } } func TestExtractIssueNumber(t *testing.T) { tests := []struct { name string issueID string expected int }{ { name: "simple number", issueID: "bd-123", expected: 123, }, { name: "hash ID (no number)", issueID: "bd-a3f8e9", expected: 0, }, { name: "hierarchical with number", issueID: "bd-42.1.2", expected: 42, }, { name: "no hyphen", issueID: "invalid", expected: 0, }, { name: "empty string", issueID: "", expected: 0, }, { name: "zero", issueID: "bd-0", expected: 0, }, { name: "large number", issueID: "bd-999999", expected: 999999, }, { name: "number with text after", issueID: "bd-123abc", expected: 123, }, { name: "hyphenated prefix with number", issueID: "alpha-beta-7", expected: 7, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := ExtractIssueNumber(tt.issueID) if result != tt.expected { t.Errorf("ExtractIssueNumber(%q) = %d; want %d", tt.issueID, result, tt.expected) } }) } } func contains(s, substr string) bool { return len(s) >= len(substr) && (s == substr || len(s) > len(substr) && (s[:len(substr)] == substr || s[len(s)-len(substr):] == substr || findSubstring(s, substr))) } func findSubstring(s, substr string) bool { for i := 0; i <= len(s)-len(substr); i++ { if s[i:i+len(substr)] == substr { return true } } return false } // TestResolvePartialID_CrossPrefix tests resolution of IDs with different prefixes // than the configured prefix. This is the GH#1513 fix for multi-repo scenarios // where issues from different rigs (with different prefixes) are hydrated into // a single database. func TestResolvePartialID_CrossPrefix(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create issues with different prefixes (simulating multi-repo hydration) hqIssue := &types.Issue{ ID: "hq-abc12", Title: "HQ Issue", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } aapIssue := &types.Issue{ ID: "aap-4ar", Title: "AAP Issue from different rig", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } crIssue := &types.Issue{ ID: "cr-xyz99", Title: "CR Issue from another rig", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, hqIssue, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, aapIssue, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, crIssue, "test"); err != nil { t.Fatal(err) } // Set config prefix to "hq" (the "town" prefix) if err := store.SetConfig(ctx, "issue_prefix", "hq"); err != nil { t.Fatal(err) } tests := []struct { name string input string expected string shouldError bool }{ { name: "configured prefix - full ID", input: "hq-abc12", expected: "hq-abc12", }, { name: "configured prefix - short ID", input: "abc12", expected: "hq-abc12", }, { name: "different prefix - full ID (GH#1513)", input: "aap-4ar", expected: "aap-4ar", }, { name: "different prefix - another rig (GH#1513)", input: "cr-xyz99", expected: "cr-xyz99", }, { name: "different prefix - short ID falls back to substring match", input: "4ar", expected: "aap-4ar", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ResolvePartialID(ctx, store, tt.input) if tt.shouldError { if err == nil { t.Errorf("ResolvePartialID(%q) expected error, got nil", tt.input) } } else { if err != nil { t.Errorf("ResolvePartialID(%q) unexpected error: %v", tt.input, err) } if result != tt.expected { t.Errorf("ResolvePartialID(%q) = %q; want %q", tt.input, result, tt.expected) } } }) } } // TestResolvePartialID_AllowedPrefixes verifies that config-aware prefix detection // in ResolvePartialID correctly handles multi-hyphen prefixes when allowed_prefixes // is set. This exercises both the normalization path (hasKnownPrefix) and the // hash extraction path (ExtractIssuePrefixKnown). func TestResolvePartialID_AllowedPrefixes(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create issues with multi-hyphen prefixes hackerNews := &types.Issue{ ID: "hacker-news-ko4", Title: "Hacker News item", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } pyToolkit := &types.Issue{ ID: "me-py-toolkit-a1b", Title: "Python toolkit issue", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } hqCvIssue := &types.Issue{ ID: "hq-cv-7x2", Title: "HQ CV issue", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, hackerNews, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, pyToolkit, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, hqCvIssue, "test"); err != nil { t.Fatal(err) } // Configure primary prefix and allowed prefixes if err := store.SetConfig(ctx, "issue_prefix", "hq"); err != nil { t.Fatal(err) } if err := store.SetConfig(ctx, "allowed_prefixes", "hacker-news, me-py-toolkit, hq-cv"); err != nil { t.Fatal(err) } tests := []struct { name string input string expected string }{ { name: "short hash resolves multi-dash prefix (ko4 -> hacker-news-ko4)", input: "ko4", expected: "hacker-news-ko4", }, { name: "short hash resolves multi-dash prefix (a1b -> me-py-toolkit-a1b)", input: "a1b", expected: "me-py-toolkit-a1b", }, { name: "full multi-dash ID is not mangled (hacker-news-ko4)", input: "hacker-news-ko4", expected: "hacker-news-ko4", }, { name: "full allowed-prefix ID resolves as-is (me-py-toolkit-a1b)", input: "me-py-toolkit-a1b", expected: "me-py-toolkit-a1b", }, { name: "overlapping prefix: hq-cv-7x2 not mangled to hq-hq-cv-7x2", input: "hq-cv-7x2", expected: "hq-cv-7x2", }, { name: "short hash with overlapping prefix (7x2 -> hq-cv-7x2)", input: "7x2", expected: "hq-cv-7x2", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ResolvePartialID(ctx, store, tt.input) if err != nil { t.Errorf("ResolvePartialID(%q) unexpected error: %v", tt.input, err) } if result != tt.expected { t.Errorf("ResolvePartialID(%q) = %q; want %q", tt.input, result, tt.expected) } }) } } // TestResolvePartialID_Wisp verifies that wisps (ephemeral issues) are resolvable // by partial ID. This exercises the explicit wisp fallback in ResolvePartialID. func TestResolvePartialID_Wisp(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Create a wisp (ephemeral issue) with a wisp-prefixed ID wisp := &types.Issue{ ID: "bd-wisp-t3st", Title: "Test wisp", Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask, Ephemeral: true, } if err := store.CreateIssue(ctx, wisp, "test"); err != nil { t.Fatal(err) } if err := store.SetConfig(ctx, "issue_prefix", "bd"); err != nil { t.Fatal(err) } tests := []struct { name string input string expected string }{ { name: "full wisp ID", input: "bd-wisp-t3st", expected: "bd-wisp-t3st", }, { name: "partial hash", input: "t3st", expected: "bd-wisp-t3st", }, { name: "wisp prefix with hash", input: "wisp-t3st", expected: "bd-wisp-t3st", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ResolvePartialID(ctx, store, tt.input) if err != nil { t.Errorf("ResolvePartialID(%q) unexpected error: %v", tt.input, err) } if result != tt.expected { t.Errorf("ResolvePartialID(%q) = %q; want %q", tt.input, result, tt.expected) } }) } } // TestResolvePartialID_TitleFalsePositive verifies that when the search query // matches an issue's title but NOT its ID, the in-memory filter correctly // rejects it. This is important because the optimization passes hashPart as // the search query (matching title/description/ID) instead of loading all issues. func TestResolvePartialID_TitleFalsePositive(t *testing.T) { ctx := context.Background() store := newTestStore(t) // Issue whose title contains "abc12" but ID does NOT decoy := &types.Issue{ ID: "bd-xyz99", Title: "See abc12 for reference", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } // Issue whose ID actually contains "abc12" target := &types.Issue{ ID: "bd-abc12", Title: "Real issue", Status: types.StatusOpen, Priority: 1, IssueType: types.TypeTask, } if err := store.CreateIssue(ctx, decoy, "test"); err != nil { t.Fatal(err) } if err := store.CreateIssue(ctx, target, "test"); err != nil { t.Fatal(err) } if err := store.SetConfig(ctx, "issue_prefix", "bd-"); err != nil { t.Fatal(err) } // Search for "abc12" — should find bd-abc12, NOT bd-xyz99 result, err := ResolvePartialID(ctx, store, "abc12") if err != nil { t.Fatalf("ResolvePartialID(%q) unexpected error: %v", "abc12", err) } if result != "bd-abc12" { t.Errorf("ResolvePartialID(%q) = %q; want %q (title match should be rejected)", "abc12", result, "bd-abc12") } } // TestLooksLikePrefixedID tests the helper function for detecting prefixed IDs func TestLooksLikePrefixedID(t *testing.T) { tests := []struct { input string expected bool }{ {"aap-4ar", true}, {"bd-abc123", true}, {"hq-xyz", true}, {"cr-99", true}, {"myproj-task1", true}, {"a-b", true}, // minimal valid prefix {"abc12345-x", true}, // 8-char prefix (max) // Invalid cases {"abc", false}, // no hyphen {"", false}, // empty {"-abc", false}, // hyphen at start {"ABC-123", false}, // uppercase {"abcdefghi-x", false}, // prefix too long (9 chars) {"abc-", false}, // empty suffix {"abc--def", false}, // suffix starts with hyphen } for _, tt := range tests { t.Run(tt.input, func(t *testing.T) { result := looksLikePrefixedID(tt.input) if result != tt.expected { t.Errorf("looksLikePrefixedID(%q) = %v; want %v", tt.input, result, tt.expected) } }) } }