d541ff48e3
isLikelyHash() required at least one digit to distinguish hashes from
English words, but base36 hashes can be all-letters by chance.
This caused ExtractIssuePrefix("xa-adt-bat") to return "xa" instead
of "xa-adt", breaking import for 20 issues in xa-adapt.
Fix: Accept all-letter suffixes for 3-char only, keep digit requirement
for 4+ chars where word collision probability is low enough (~0.2%).
Rationale:
- 3-char: 36³ = 46K hashes, ~1000 common words = ~2% collision
- 4-char: 36⁴ = 1.6M hashes, ~3000 words = ~0.2% collision
- 5+ char: collision rate negligible
509 lines
12 KiB
Go
509 lines
12 KiB
Go
package utils
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/storage/memory"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
)
|
|
|
|
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 := memory.New("")
|
|
|
|
// 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 := memory.New("")
|
|
|
|
// 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 := memory.New("")
|
|
|
|
// 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 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",
|
|
issueID: "vc-baseline-test",
|
|
expected: "vc", // Falls back to first hyphen for non-numeric suffix
|
|
},
|
|
{
|
|
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)
|
|
},
|
|
}
|
|
|
|
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 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
|
|
}
|