beads/cmd/bd/gitlab_sync_test.go
obsidian a7f9e86319 fix: resolve remaining errcheck violations in gitlab files
Add explicit error suppression (`_ =`) for unchecked resp.Body.Close()
in internal/gitlab/client.go and unchecked json.NewEncoder, w.Write,
json.NewDecoder, and os.Setenv/Unsetenv calls in gitlab test files.
Replace os.Setenv/Unsetenv with t.Setenv in gitlab_test.go for
automatic cleanup.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Executed-By: beads/polecats/obsidian
Rig: beads
Role: polecats
2026-02-02 15:09:06 -07:00

873 lines
26 KiB
Go

// Package main provides the bd CLI commands.
package main
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/gitlab"
"github.com/steveyegge/beads/internal/types"
)
// TestDoPullFromGitLab_Success verifies pulling issues from GitLab creates beads issues.
func TestDoPullFromGitLab_Success(t *testing.T) {
// Mock GitLab API server
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
issues := []gitlab.Issue{
{
ID: 1,
IID: 1,
ProjectID: 123,
Title: "Test issue",
Description: "Test description",
State: "opened",
Labels: []string{"type::bug", "priority::high"},
WebURL: "https://gitlab.example.com/group/project/-/issues/1",
},
}
_ = json.NewEncoder(w).Encode(issues)
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext() // Use SyncContext instead of globals
stats, err := doPullFromGitLabWithContext(ctx, syncCtx, client, config, false, "all", nil)
if err != nil {
t.Fatalf("doPullFromGitLabWithContext() error = %v", err)
}
if stats.Created != 1 {
t.Errorf("stats.Created = %d, want 1", stats.Created)
}
}
// TestDoPullFromGitLab_DryRun verifies dry run mode doesn't create issues.
func TestDoPullFromGitLab_DryRun(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
issues := []gitlab.Issue{
{
ID: 1,
IID: 1,
ProjectID: 123,
Title: "Test issue",
State: "opened",
WebURL: "https://gitlab.example.com/group/project/-/issues/1",
},
}
_ = json.NewEncoder(w).Encode(issues)
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
stats, err := doPullFromGitLabWithContext(ctx, syncCtx, client, config, true, "all", nil)
if err != nil {
t.Fatalf("doPullFromGitLabWithContext() error = %v", err)
}
// Dry run should report what would be created but not actually create
if stats.Created != 0 {
t.Errorf("dry run stats.Created = %d, want 0", stats.Created)
}
}
// TestDoPullFromGitLab_SkipIssues verifies skipGitLabIIDs filters issues.
func TestDoPullFromGitLab_SkipIssues(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
issues := []gitlab.Issue{
{ID: 1, IID: 1, ProjectID: 123, Title: "Issue 1", State: "opened", WebURL: "https://gitlab.example.com/-/issues/1"},
{ID: 2, IID: 2, ProjectID: 123, Title: "Issue 2", State: "opened", WebURL: "https://gitlab.example.com/-/issues/2"},
{ID: 3, IID: 3, ProjectID: 123, Title: "Issue 3", State: "opened", WebURL: "https://gitlab.example.com/-/issues/3"},
}
_ = json.NewEncoder(w).Encode(issues)
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
// Skip issue IID 2
skipIIDs := map[int]bool{2: true}
stats, err := doPullFromGitLabWithContext(ctx, syncCtx, client, config, false, "all", skipIIDs)
if err != nil {
t.Fatalf("doPullFromGitLabWithContext() error = %v", err)
}
if stats.Skipped != 1 {
t.Errorf("stats.Skipped = %d, want 1", stats.Skipped)
}
}
// TestDoPushToGitLab_CreateNew verifies pushing new issues to GitLab.
func TestDoPushToGitLab_CreateNew(t *testing.T) {
var createCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
createCalled = true
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusCreated)
_ = json.NewEncoder(w).Encode(gitlab.Issue{
ID: 100,
IID: 42,
Title: "New issue",
State: "opened",
WebURL: "https://gitlab.example.com/-/issues/42",
})
return
}
// GET requests for fetching issues
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode([]gitlab.Issue{})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
// Create a local issue without external ref (new issue)
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "New issue",
Description: "New issue description",
IssueType: types.TypeBug,
Priority: 1,
Status: types.StatusOpen,
},
}
stats, err := doPushToGitLabWithContext(ctx, syncCtx, client, config, localIssues, false, false, nil, nil)
if err != nil {
t.Fatalf("doPushToGitLabWithContext() error = %v", err)
}
if !createCalled {
t.Error("GitLab create API was not called")
}
if stats.Created != 1 {
t.Errorf("stats.Created = %d, want 1", stats.Created)
}
}
// TestDoPushToGitLab_UpdateExisting verifies updating existing GitLab issues.
func TestDoPushToGitLab_UpdateExisting(t *testing.T) {
var updateCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPut {
updateCalled = true
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(gitlab.Issue{
ID: 100,
IID: 42,
Title: "Updated issue",
State: "opened",
WebURL: "https://gitlab.example.com/-/issues/42",
})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
// Create a local issue with external ref (existing issue)
webURL := "https://gitlab.example.com/-/issues/42"
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "Updated issue",
Description: "Updated description",
IssueType: types.TypeBug,
Priority: 1,
Status: types.StatusOpen,
ExternalRef: &webURL,
SourceSystem: "gitlab:123:42",
},
}
stats, err := doPushToGitLabWithContext(ctx, syncCtx, client, config, localIssues, false, false, nil, nil)
if err != nil {
t.Fatalf("doPushToGitLabWithContext() error = %v", err)
}
if !updateCalled {
t.Error("GitLab update API was not called")
}
if stats.Updated != 1 {
t.Errorf("stats.Updated = %d, want 1", stats.Updated)
}
}
// TestDetectGitLabConflicts_NoConflicts verifies no conflicts detected when timestamps match.
func TestDetectGitLabConflicts_NoConflicts(t *testing.T) {
now := time.Now()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode([]gitlab.Issue{
{
ID: 100,
IID: 42,
ProjectID: 123,
Title: "Same title",
State: "opened",
UpdatedAt: &now,
WebURL: "https://gitlab.example.com/-/issues/42",
},
})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
ctx := context.Background()
syncCtx := NewSyncContext()
// Local issue with same updated_at timestamp
webURL := "https://gitlab.example.com/-/issues/42"
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "Same title",
UpdatedAt: now,
ExternalRef: &webURL,
SourceSystem: "gitlab:123:42",
},
}
conflicts, err := detectGitLabConflictsWithContext(ctx, syncCtx, client, localIssues)
if err != nil {
t.Fatalf("detectGitLabConflictsWithContext() error = %v", err)
}
if len(conflicts) != 0 {
t.Errorf("detectGitLabConflictsWithContext() returned %d conflicts, want 0", len(conflicts))
}
}
// TestDetectGitLabConflicts_WithConflicts verifies conflicts detected when both sides updated.
func TestDetectGitLabConflicts_WithConflicts(t *testing.T) {
baseTime := time.Now().Add(-1 * time.Hour)
gitlabTime := time.Now().Add(-30 * time.Minute)
localTime := time.Now().Add(-15 * time.Minute)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode([]gitlab.Issue{
{
ID: 100,
IID: 42,
ProjectID: 123,
Title: "GitLab title",
State: "opened",
UpdatedAt: &gitlabTime,
WebURL: "https://gitlab.example.com/-/issues/42",
},
})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
ctx := context.Background()
syncCtx := NewSyncContext()
// Local issue updated more recently than base but GitLab also updated
webURL := "https://gitlab.example.com/-/issues/42"
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "Local title",
UpdatedAt: localTime,
ExternalRef: &webURL,
SourceSystem: "gitlab:123:42",
},
}
// Set base time (simulating last sync)
_ = baseTime // Used for understanding, actual comparison is local vs gitlab
conflicts, err := detectGitLabConflictsWithContext(ctx, syncCtx, client, localIssues)
if err != nil {
t.Fatalf("detectGitLabConflictsWithContext() error = %v", err)
}
if len(conflicts) != 1 {
t.Errorf("detectGitLabConflictsWithContext() returned %d conflicts, want 1", len(conflicts))
}
}
// TestDoPushToGitLab_PathBasedProjectID verifies push works with path-based project IDs.
func TestDoPushToGitLab_PathBasedProjectID(t *testing.T) {
var updateCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPut {
updateCalled = true
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(gitlab.Issue{
ID: 100,
IID: 42,
ProjectID: 789, // Numeric project ID from API
Title: "Updated issue",
State: "opened",
WebURL: "https://gitlab.example.com/group/project/-/issues/42",
})
}))
defer server.Close()
// Client configured with path-based project ID
client := gitlab.NewClient("token", server.URL, "group/project")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
// Local issue linked to numeric project ID 789 (same project, different representation)
webURL := "https://gitlab.example.com/group/project/-/issues/42"
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "Updated issue",
Description: "Updated description",
IssueType: types.TypeBug,
Priority: 1,
Status: types.StatusOpen,
ExternalRef: &webURL,
SourceSystem: "gitlab:789:42", // Numeric project ID from previous sync
},
}
stats, err := doPushToGitLabWithContext(ctx, syncCtx, client, config, localIssues, false, false, nil, nil)
if err != nil {
t.Fatalf("doPushToGitLabWithContext() error = %v", err)
}
// Should update, not skip - the path "group/project" and numeric 789 are the same project
if !updateCalled {
t.Error("GitLab update API was not called - path-based project ID comparison failed")
}
if stats.Updated != 1 {
t.Errorf("stats.Updated = %d, want 1 (got skipped due to project ID mismatch)", stats.Updated)
}
}
// TestGenerateUniqueIssueIDs verifies IDs are unique even when generated rapidly.
func TestGenerateUniqueIssueIDs(t *testing.T) {
seen := make(map[string]bool)
prefix := "bd"
// Generate 100 IDs rapidly
for i := 0; i < 100; i++ {
id := generateIssueID(prefix)
if seen[id] {
t.Errorf("Duplicate ID generated: %s", id)
}
seen[id] = true
}
}
// TestGenerateIssueIDHasRandomComponent verifies IDs include random bytes for restart safety.
// Without random bytes, counter reset on restart could cause ID collisions.
func TestGenerateIssueIDHasRandomComponent(t *testing.T) {
// Save current counter
oldCounter := issueIDCounter
defer func() { issueIDCounter = oldCounter }()
prefix := "test"
// Generate ID, reset counter (simulating restart), generate another
// Both generated at same counter value - should still be unique due to random component
issueIDCounter = 100
id1 := generateIssueID(prefix)
// Simulate restart by resetting counter to same value
issueIDCounter = 100
id2 := generateIssueID(prefix)
// Even with same counter, IDs should differ due to random component
// Note: timestamp might also differ, but within same millisecond they'd collide without randomness
if id1 == id2 {
t.Errorf("IDs should be unique even with counter reset: id1=%s, id2=%s", id1, id2)
}
// Verify format includes hex suffix (random bytes)
// Expected format: prefix-timestamp-counter-hex
parts := strings.Split(id1, "-")
if len(parts) != 4 {
t.Errorf("Expected 4 parts (prefix-timestamp-counter-random), got %d: %s", len(parts), id1)
}
}
// TestGetConflictStrategy verifies conflict strategy selection from flags.
func TestGetConflictStrategy(t *testing.T) {
tests := []struct {
name string
preferLocal bool
preferGitLab bool
preferNewer bool
wantStrategy ConflictStrategy
wantError bool
}{
{
name: "no flags - default to prefer-newer",
wantStrategy: ConflictStrategyPreferNewer,
},
{
name: "prefer-local",
preferLocal: true,
wantStrategy: ConflictStrategyPreferLocal,
},
{
name: "prefer-gitlab",
preferGitLab: true,
wantStrategy: ConflictStrategyPreferGitLab,
},
{
name: "prefer-newer explicit",
preferNewer: true,
wantStrategy: ConflictStrategyPreferNewer,
},
{
name: "multiple flags - error",
preferLocal: true,
preferGitLab: true,
wantError: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
strategy, err := getConflictStrategy(tt.preferLocal, tt.preferGitLab, tt.preferNewer)
if tt.wantError {
if err == nil {
t.Error("expected error for multiple flags, got nil")
}
return
}
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if strategy != tt.wantStrategy {
t.Errorf("strategy = %q, want %q", strategy, tt.wantStrategy)
}
})
}
}
// TestResolveConflicts_PreferLocal verifies --prefer-local always uses local version.
func TestResolveConflicts_PreferLocal(t *testing.T) {
localTime := time.Now().Add(-1 * time.Hour) // Local is OLDER
gitlabTime := time.Now() // GitLab is newer
var fetchCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fetchCalled = true
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(gitlab.Issue{})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
ctx := context.Background()
syncCtx := NewSyncContext()
conflicts := []gitlab.Conflict{
{
IssueID: "bd-1",
LocalUpdated: localTime,
GitLabUpdated: gitlabTime, // GitLab is newer, but we prefer local
GitLabIID: 42,
GitLabID: 100,
},
}
// Should NOT fetch from GitLab when preferring local
err := resolveGitLabConflictsWithContext(ctx, syncCtx, client, nil, conflicts, ConflictStrategyPreferLocal)
if err != nil {
t.Fatalf("resolveGitLabConflictsWithContext() error = %v", err)
}
if fetchCalled {
t.Error("GitLab API was called when --prefer-local should skip remote fetch")
}
}
// TestResolveConflicts_PreferGitLab verifies --prefer-gitlab always fetches from GitLab.
func TestResolveConflicts_PreferGitLab(t *testing.T) {
localTime := time.Now() // Local is newer
gitlabTime := time.Now().Add(-1 * time.Hour) // GitLab is OLDER
var fetchCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fetchCalled = true
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(gitlab.Issue{
ID: 100,
IID: 42,
ProjectID: 123,
Title: "GitLab title",
Description: "GitLab description",
State: "opened",
UpdatedAt: &gitlabTime,
WebURL: "https://gitlab.example.com/-/issues/42",
})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
conflicts := []gitlab.Conflict{
{
IssueID: "bd-1",
LocalUpdated: localTime, // Local is newer, but we prefer gitlab
GitLabUpdated: gitlabTime,
GitLabIID: 42,
GitLabID: 100,
},
}
// Should fetch from GitLab even though local is newer
err := resolveGitLabConflictsWithContext(ctx, syncCtx, client, config, conflicts, ConflictStrategyPreferGitLab)
if err != nil {
t.Fatalf("resolveGitLabConflictsWithContext() error = %v", err)
}
if !fetchCalled {
t.Error("GitLab API was NOT called when --prefer-gitlab should always fetch")
}
}
// TestResolveConflicts_PreferNewer verifies default behavior uses timestamps.
func TestResolveConflicts_PreferNewer(t *testing.T) {
localTime := time.Now().Add(-1 * time.Hour) // Local is older
gitlabTime := time.Now() // GitLab is newer
var fetchCalled bool
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fetchCalled = true
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(gitlab.Issue{
ID: 100,
IID: 42,
ProjectID: 123,
Title: "GitLab title",
State: "opened",
UpdatedAt: &gitlabTime,
WebURL: "https://gitlab.example.com/-/issues/42",
})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
conflicts := []gitlab.Conflict{
{
IssueID: "bd-1",
LocalUpdated: localTime,
GitLabUpdated: gitlabTime, // GitLab is newer
GitLabIID: 42,
GitLabID: 100,
},
}
// GitLab is newer, so should fetch from GitLab
err := resolveGitLabConflictsWithContext(ctx, syncCtx, client, config, conflicts, ConflictStrategyPreferNewer)
if err != nil {
t.Fatalf("resolveGitLabConflictsWithContext() error = %v", err)
}
if !fetchCalled {
t.Error("GitLab API was NOT called when GitLab version is newer")
}
}
// =============================================================================
// P0 BUG FIX TESTS
// =============================================================================
// TestP0_ConflictDetectionBeforePush verifies that conflict detection happens
// BEFORE push, not after. This is critical because pushing before detecting
// conflicts can cause data loss - conflicting local changes overwrite GitLab
// changes before we even know there's a conflict.
//
// BUG: The current implementation does: Pull -> Push -> Detect conflicts (WRONG)
// FIX: Should be: Pull -> Detect conflicts -> Push (skip conflicting issues)
func TestP0_ConflictDetectionBeforePush(t *testing.T) {
localTime := time.Now()
gitlabTime := time.Now().Add(-30 * time.Minute)
var pushCalls []int // Track which issue IIDs were pushed
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if r.Method == http.MethodGet {
// Return issues for conflict detection
_ = json.NewEncoder(w).Encode([]gitlab.Issue{
{
ID: 100,
IID: 42,
ProjectID: 123,
Title: "GitLab version",
State: "opened",
UpdatedAt: &gitlabTime,
WebURL: "https://gitlab.example.com/-/issues/42",
},
{
ID: 101,
IID: 43,
ProjectID: 123,
Title: "Another issue",
State: "opened",
UpdatedAt: &gitlabTime,
WebURL: "https://gitlab.example.com/-/issues/43",
},
})
return
}
if r.Method == http.MethodPut {
// Track which issue was pushed (extract IID from URL)
// URL format: /api/v4/projects/123/issues/42
parts := strings.Split(r.URL.Path, "/")
if len(parts) >= 2 {
if iid, err := strconv.Atoi(parts[len(parts)-1]); err == nil {
pushCalls = append(pushCalls, iid)
}
}
_ = json.NewEncoder(w).Encode(gitlab.Issue{})
return
}
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
syncCtx := NewSyncContext()
// Local issues - issue 42 is in conflict (local modified), issue 43 is safe
webURL42 := "https://gitlab.example.com/-/issues/42"
webURL43 := "https://gitlab.example.com/-/issues/43"
localIssues := []*types.Issue{
{
ID: "bd-1",
Title: "Local version", // Different from GitLab
UpdatedAt: localTime, // More recent than GitLab
ExternalRef: &webURL42,
SourceSystem: "gitlab:123:42",
},
{
ID: "bd-2",
Title: "Another issue", // Same as GitLab
UpdatedAt: gitlabTime, // Same time as GitLab (no conflict)
ExternalRef: &webURL43,
SourceSystem: "gitlab:123:43",
},
}
// Detect conflicts BEFORE push
conflicts, err := detectGitLabConflictsWithContext(ctx, syncCtx, client, localIssues)
if err != nil {
t.Fatalf("detectGitLabConflictsWithContext() error = %v", err)
}
// Should detect conflict for issue 42 (timestamps differ)
if len(conflicts) != 1 {
t.Fatalf("expected 1 conflict, got %d", len(conflicts))
}
if conflicts[0].GitLabIID != 42 {
t.Errorf("expected conflict for IID 42, got %d", conflicts[0].GitLabIID)
}
// Build skipUpdateIDs from conflicts
skipUpdateIDs := make(map[string]bool)
for _, c := range conflicts {
skipUpdateIDs[c.IssueID] = true
}
// Push should skip conflicting issues
stats, err := doPushToGitLabWithContext(ctx, syncCtx, client, config, localIssues, false, false, nil, skipUpdateIDs)
if err != nil {
t.Fatalf("doPushToGitLabWithContext() error = %v", err)
}
// Issue 42 should be skipped, only issue 43 should be pushed
if stats.Skipped != 1 {
t.Errorf("stats.Skipped = %d, want 1 (conflict issue should be skipped)", stats.Skipped)
}
if stats.Updated != 1 {
t.Errorf("stats.Updated = %d, want 1 (non-conflict issue should be pushed)", stats.Updated)
}
// Verify the push call was only for issue 43, not 42
for _, iid := range pushCalls {
if iid == 42 {
t.Error("CRITICAL: Issue 42 was pushed despite being in conflict - this causes data loss!")
}
}
}
// TestP0_SyncContextIsolation verifies that SyncContext can be used instead of
// global variables, allowing multiple sync operations to run concurrently
// without race conditions.
//
// BUG: Current implementation uses global variables (store, actor, dbPath, issueIDCounter)
// FIX: Should use SyncContext struct passed to functions
func TestP0_SyncContextIsolation(t *testing.T) {
// Test that SyncContext exists and can hold required state
// This test will fail until SyncContext is implemented
ctx1 := NewSyncContext()
ctx2 := NewSyncContext()
// Verify contexts are independent
if ctx1 == ctx2 {
t.Error("NewSyncContext should return distinct instances")
}
// Verify context can hold store reference
ctx1.SetActor("user1")
ctx2.SetActor("user2")
if ctx1.Actor() == ctx2.Actor() {
t.Error("SyncContext instances should have independent actor values")
}
// Verify issue ID generation is isolated per context
id1 := ctx1.GenerateIssueID("bd")
id2 := ctx2.GenerateIssueID("bd")
if id1 == id2 {
t.Error("Issue IDs generated from different contexts should be unique")
}
}
// TestP0_SyncFunctionsUseSyncContext verifies that sync functions accept
// SyncContext instead of relying on global variables.
func TestP0_SyncFunctionsUseSyncContext(t *testing.T) {
// Save and restore global store to avoid interfering with other tests
oldStore := store
store = nil
defer func() { store = oldStore }()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode([]gitlab.Issue{})
}))
defer server.Close()
client := gitlab.NewClient("token", server.URL, "123")
config := gitlab.DefaultMappingConfig()
ctx := context.Background()
// Create a SyncContext
syncCtx := NewSyncContext()
syncCtx.SetActor("test-actor")
// These function calls should work with SyncContext
// The test verifies the API exists and compiles
_, err := doPullFromGitLabWithContext(ctx, syncCtx, client, config, false, "all", nil)
if err != nil {
// Expected to fail if not implemented, but should compile
t.Logf("doPullFromGitLabWithContext returned error (expected if not implemented): %v", err)
}
_, err = doPushToGitLabWithContext(ctx, syncCtx, client, config, nil, false, false, nil, nil)
if err != nil {
t.Logf("doPushToGitLabWithContext returned error (expected if not implemented): %v", err)
}
_, err = detectGitLabConflictsWithContext(ctx, syncCtx, client, nil)
if err != nil {
t.Logf("detectGitLabConflictsWithContext returned error (expected if not implemented): %v", err)
}
err = resolveGitLabConflictsWithContext(ctx, syncCtx, client, config, nil, ConflictStrategyPreferNewer)
if err != nil {
t.Logf("resolveGitLabConflictsWithContext returned error (expected if not implemented): %v", err)
}
}
// =============================================================================
// END P0 BUG FIX TESTS
// =============================================================================
// TestParseGitLabSourceSystem verifies parsing source system string.
func TestParseGitLabSourceSystem(t *testing.T) {
tests := []struct {
name string
sourceSystem string
wantProjectID int
wantIID int
wantOK bool
}{
{
name: "valid gitlab source",
sourceSystem: "gitlab:123:42",
wantProjectID: 123,
wantIID: 42,
wantOK: true,
},
{
name: "different project",
sourceSystem: "gitlab:456:99",
wantProjectID: 456,
wantIID: 99,
wantOK: true,
},
{
name: "non-gitlab source",
sourceSystem: "linear:ABC-123",
wantProjectID: 0,
wantIID: 0,
wantOK: false,
},
{
name: "empty source",
sourceSystem: "",
wantProjectID: 0,
wantIID: 0,
wantOK: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
projectID, iid, ok := parseGitLabSourceSystem(tt.sourceSystem)
if ok != tt.wantOK {
t.Errorf("parseGitLabSourceSystem(%q) ok = %v, want %v", tt.sourceSystem, ok, tt.wantOK)
}
if projectID != tt.wantProjectID {
t.Errorf("parseGitLabSourceSystem(%q) projectID = %d, want %d", tt.sourceSystem, projectID, tt.wantProjectID)
}
if iid != tt.wantIID {
t.Errorf("parseGitLabSourceSystem(%q) iid = %d, want %d", tt.sourceSystem, iid, tt.wantIID)
}
})
}
}