beads/internal/tracker/engine_test.go
2026-05-12 09:53:56 -07:00

2998 lines
93 KiB
Go

//go:build cgo
package tracker
import (
"context"
"fmt"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/testutil"
"github.com/steveyegge/beads/internal/types"
)
// newTestStore creates a dolt store on the shared database with branch isolation.
func newTestStore(t *testing.T) *dolt.DoltStore {
t.Helper()
testutil.RequireDoltBinary(t)
if testServerPort == 0 || testSharedDB == "" {
t.Skip("shared test Dolt database not initialized, skipping test")
}
ctx := context.Background()
store, err := dolt.New(ctx, &dolt.Config{
Path: t.TempDir(),
ServerHost: "127.0.0.1",
ServerPort: testServerPort,
Database: testSharedDB,
MaxOpenConns: 1,
})
if err != nil {
t.Fatalf("Failed to create dolt store: %v", err)
}
// Create an isolated branch for this test
_, branchCleanup := testutil.StartTestBranch(t, store.DB(), testSharedDB)
t.Cleanup(func() {
branchCleanup()
store.Close()
})
return store
}
// mockTracker implements IssueTracker for testing.
type mockTracker struct {
name string
issues []TrackerIssue
created []*types.Issue
updated map[string]*types.Issue
fetchErr error
fetchIssueErr error
createErr error
createFailAfter int // fail after this many successful creates (0 = fail immediately)
updateErr error
fieldMapper FieldMapper
fetchIssues func(context.Context, FetchOptions) ([]TrackerIssue, error)
}
type mockExternalRefTracker struct {
*mockTracker
buildRef func(*TrackerIssue) string
extract func(string) string
isRef func(string) bool
}
type mockBatchTracker struct {
*mockTracker
batchResult *BatchPushResult
batchDryRun *BatchPushResult
batchErr error
batchCalls int
batchDryCalls int
batchIssues []*types.Issue
batchForceIDs map[string]bool
}
func newMockTracker(name string) *mockTracker {
return &mockTracker{
name: name,
updated: make(map[string]*types.Issue),
fieldMapper: &mockMapper{},
}
}
func (m *mockExternalRefTracker) IsExternalRef(ref string) bool {
if m.isRef != nil {
return m.isRef(ref)
}
return m.mockTracker.IsExternalRef(ref)
}
func (m *mockExternalRefTracker) ExtractIdentifier(ref string) string {
if m.extract != nil {
return m.extract(ref)
}
return m.mockTracker.ExtractIdentifier(ref)
}
func (m *mockExternalRefTracker) BuildExternalRef(issue *TrackerIssue) string {
if m.buildRef != nil {
return m.buildRef(issue)
}
return m.mockTracker.BuildExternalRef(issue)
}
func (m *mockTracker) Name() string { return m.name }
func (m *mockTracker) DisplayName() string { return m.name }
func (m *mockTracker) ConfigPrefix() string { return m.name }
func (m *mockTracker) Init(_ context.Context, _ storage.Storage) error { return nil }
func (m *mockTracker) Validate() error { return nil }
func (m *mockTracker) Close() error { return nil }
func (m *mockTracker) FieldMapper() FieldMapper { return m.fieldMapper }
func (m *mockTracker) IsExternalRef(ref string) bool { return len(ref) > 0 }
func (m *mockTracker) ExtractIdentifier(ref string) string {
// Extract "EXT-1" from "https://test.test/EXT-1"
if i := strings.LastIndex(ref, "/"); i >= 0 {
return ref[i+1:]
}
return ref
}
func (m *mockTracker) BuildExternalRef(issue *TrackerIssue) string {
return fmt.Sprintf("https://%s.test/%s", m.name, issue.Identifier)
}
func (m *mockBatchTracker) BatchPush(_ context.Context, issues []*types.Issue, forceIDs map[string]bool) (*BatchPushResult, error) {
if m.batchErr != nil {
return nil, m.batchErr
}
m.batchCalls++
m.batchIssues = append(m.batchIssues, issues...)
m.batchForceIDs = forceIDs
if m.batchResult != nil {
return m.batchResult, nil
}
return &BatchPushResult{}, nil
}
func (m *mockBatchTracker) BatchPushDryRun(_ context.Context, issues []*types.Issue, forceIDs map[string]bool) (*BatchPushResult, error) {
if m.batchErr != nil {
return nil, m.batchErr
}
m.batchDryCalls++
m.batchIssues = append(m.batchIssues, issues...)
m.batchForceIDs = forceIDs
if m.batchDryRun != nil {
return m.batchDryRun, nil
}
return &BatchPushResult{}, nil
}
func (m *mockTracker) FetchIssues(ctx context.Context, opts FetchOptions) ([]TrackerIssue, error) {
if m.fetchErr != nil {
return nil, m.fetchErr
}
if m.fetchIssues != nil {
return m.fetchIssues(ctx, opts)
}
return m.issues, nil
}
func (m *mockTracker) FetchIssue(_ context.Context, identifier string) (*TrackerIssue, error) {
if m.fetchIssueErr != nil {
return nil, m.fetchIssueErr
}
if m.fetchErr != nil {
return nil, m.fetchErr
}
for i := range m.issues {
if m.issues[i].Identifier == identifier {
return &m.issues[i], nil
}
}
return nil, nil
}
func (m *mockTracker) CreateIssue(_ context.Context, issue *types.Issue) (*TrackerIssue, error) {
if m.createErr != nil {
if m.createFailAfter > 0 && len(m.created) < m.createFailAfter {
// Allow first N creates to succeed
} else {
return nil, m.createErr
}
}
m.created = append(m.created, issue)
return &TrackerIssue{
ID: "ext-" + issue.ID,
Identifier: "EXT-" + issue.ID,
URL: fmt.Sprintf("https://%s.test/EXT-%s", m.name, issue.ID),
Title: issue.Title,
}, nil
}
func (m *mockTracker) UpdateIssue(_ context.Context, externalID string, issue *types.Issue) (*TrackerIssue, error) {
if m.updateErr != nil {
return nil, m.updateErr
}
m.updated[externalID] = issue
return &TrackerIssue{
ID: externalID,
Identifier: externalID,
Title: issue.Title,
}, nil
}
// mockMapper implements FieldMapper for testing.
type mockMapper struct {
issueToBeads func(*TrackerIssue) *IssueConversion
}
func (m *mockMapper) PriorityToBeads(p interface{}) int {
if v, ok := p.(int); ok {
return v
}
return 2
}
func (m *mockMapper) PriorityToTracker(p int) interface{} { return p }
func (m *mockMapper) StatusToBeads(_ interface{}) types.Status { return types.StatusOpen }
func (m *mockMapper) StatusToTracker(s types.Status) interface{} { return string(s) }
func (m *mockMapper) TypeToBeads(_ interface{}) types.IssueType { return types.TypeTask }
func (m *mockMapper) TypeToTracker(t types.IssueType) interface{} { return string(t) }
func (m *mockMapper) IssueToTracker(issue *types.Issue) map[string]interface{} {
return map[string]interface{}{
"title": issue.Title,
"description": issue.Description,
}
}
func (m *mockMapper) IssueToBeads(ti *TrackerIssue) *IssueConversion {
if m.issueToBeads != nil {
return m.issueToBeads(ti)
}
return &IssueConversion{
Issue: &types.Issue{
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
},
}
}
func TestEnginePullMatchesExistingIssueByLocalID(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue := &types.Issue{
ID: "bd-local",
Title: "Local title",
Description: "Local description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
UpdatedAt: time.Now().UTC().Add(-2 * time.Hour),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: "https://test.test/EXT-1",
Title: "Remote title",
Description: "Remote description",
UpdatedAt: time.Now().UTC(),
}}
tracker.fieldMapper = &mockMapper{
issueToBeads: func(ti *TrackerIssue) *IssueConversion {
return &IssueConversion{
Issue: &types.Issue{
ID: "bd-local",
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
},
}
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.PullStats.Created != 0 || result.PullStats.Updated != 1 {
t.Fatalf("PullStats = %+v, want Created=0 Updated=1", result.PullStats)
}
updated, err := store.GetIssue(ctx, "bd-local")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if updated.Title != "Remote title" || updated.Description != "Remote description" {
t.Fatalf("issue = %+v", updated)
}
}
func TestEnginePullSkipsNoopUpdate(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
extRef := "https://www.notion.so/32be5bf97fae804d9e07f93af6c79467"
issue := &types.Issue{
ID: "bd-local",
Title: "Remote title",
Description: "Remote description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
Assignee: "Osamu",
Labels: []string{"alpha", "beta"},
ExternalRef: &extRef,
UpdatedAt: time.Now().UTC().Add(-2 * time.Hour),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: extRef,
Title: "Remote title",
Description: "Remote description",
UpdatedAt: time.Now().UTC(),
}}
tracker.fieldMapper = &mockMapper{
issueToBeads: func(ti *TrackerIssue) *IssueConversion {
return &IssueConversion{
Issue: &types.Issue{
ID: "bd-local",
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Assignee: "Osamu",
Labels: []string{"beta", "alpha"},
},
}
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.PullStats.Created != 0 || result.PullStats.Updated != 0 || result.PullStats.Skipped != 1 {
t.Fatalf("PullStats = %+v, want Created=0 Updated=0 Skipped=1", result.PullStats)
}
}
func TestEnginePullUpdatesLabelsOnExistingIssue(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
extRef := "https://www.notion.so/32be5bf97fae804d9e07f93af6c79467"
issue := &types.Issue{
ID: "bd-local",
Title: "Remote title",
Description: "Remote description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
Assignee: "Osamu",
Labels: []string{"old-label"},
ExternalRef: &extRef,
UpdatedAt: time.Now().UTC().Add(-2 * time.Hour),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: extRef,
Title: "Remote title",
Description: "Remote description",
Labels: []string{"new-a", "new-b"},
UpdatedAt: time.Now().UTC(),
}}
tracker.fieldMapper = &mockMapper{
issueToBeads: func(ti *TrackerIssue) *IssueConversion {
return &IssueConversion{
Issue: &types.Issue{
ID: "bd-local",
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Assignee: "Osamu",
Labels: append([]string(nil), ti.Labels...),
},
}
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.PullStats.Updated != 1 {
t.Fatalf("PullStats = %+v, want Updated=1", result.PullStats)
}
labels, err := store.GetLabels(ctx, "bd-local")
if err != nil {
t.Fatalf("GetLabels() error: %v", err)
}
if !equalNormalizedStrings(labels, []string{"new-a", "new-b"}) {
t.Fatalf("labels = %v, want [new-a new-b]", labels)
}
}
func TestEnginePullDryRunTreatsLabelOnlyChangeAsUpdate(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
extRef := "https://www.notion.so/32be5bf97fae804d9e07f93af6c79467"
issue := &types.Issue{
ID: "bd-local",
Title: "Remote title",
Description: "Remote description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
Assignee: "Osamu",
Labels: []string{"old-label"},
ExternalRef: &extRef,
UpdatedAt: time.Now().UTC().Add(-2 * time.Hour),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: extRef,
Title: "Remote title",
Description: "Remote description",
Labels: []string{"new-label"},
UpdatedAt: time.Now().UTC(),
}}
tracker.fieldMapper = &mockMapper{
issueToBeads: func(ti *TrackerIssue) *IssueConversion {
return &IssueConversion{
Issue: &types.Issue{
ID: "bd-local",
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Assignee: "Osamu",
Labels: append([]string(nil), ti.Labels...),
},
}
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true, DryRun: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.PullStats.Updated != 1 || result.PullStats.Created != 0 {
t.Fatalf("PullStats = %+v, want Updated=1 Created=0", result.PullStats)
}
labels, err := store.GetLabels(ctx, "bd-local")
if err != nil {
t.Fatalf("GetLabels() error: %v", err)
}
if !equalNormalizedStrings(labels, []string{"old-label"}) {
t.Fatalf("labels = %v, want [old-label]", labels)
}
}
func TestEnginePullDoesNotTreatPreviousPullAsLocalConflict(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
extRef := "https://www.notion.so/32be5bf97fae804d9e07f93af6c79467"
issue := &types.Issue{
ID: "bd-local",
Title: "Local title",
Description: "Local description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: &extRef,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.fieldMapper = &mockMapper{
issueToBeads: func(ti *TrackerIssue) *IssueConversion {
return &IssueConversion{
Issue: &types.Issue{
ID: "bd-local",
Title: ti.Title,
Description: ti.Description,
Priority: 2,
Status: types.StatusOpen,
IssueType: types.TypeTask,
},
}
},
}
engine := NewEngine(tracker, store, "test-actor")
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: extRef,
Title: "Remote title 1",
Description: "Remote description 1",
UpdatedAt: time.Now().UTC(),
}}
if _, err := engine.Sync(ctx, SyncOptions{Pull: true}); err != nil {
t.Fatalf("first Sync() error: %v", err)
}
tracker.issues = []TrackerIssue{{
ID: "EXT-1",
Identifier: "EXT-1",
URL: extRef,
Title: "Remote title 2",
Description: "Remote description 2",
UpdatedAt: time.Now().UTC().Add(time.Second),
}}
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("second Sync() error: %v", err)
}
if result.PullStats.Updated != 1 {
t.Fatalf("second PullStats = %+v, want Updated=1", result.PullStats)
}
updated, err := store.GetIssue(ctx, "bd-local")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if updated.Description != "Remote description 2" {
t.Fatalf("description = %q, want %q", updated.Description, "Remote description 2")
}
}
func TestEnginePullOnly(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "First issue", Description: "Desc 1", UpdatedAt: time.Now()},
{ID: "2", Identifier: "TEST-2", Title: "Second issue", Description: "Desc 2", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Errorf("Sync() not successful: %s", result.Error)
}
if result.Stats.Created != 2 {
t.Errorf("Stats.Created = %d, want 2", result.Stats.Created)
}
if result.PullStats.Created != 2 || result.PullStats.Updated != 0 {
t.Errorf("PullStats = %+v, want Created=2 Updated=0", result.PullStats)
}
if result.PushStats.Created != 0 || result.PushStats.Updated != 0 {
t.Errorf("PushStats = %+v, want zero value", result.PushStats)
}
// Verify issues were stored
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 2 {
t.Errorf("stored %d issues, want 2", len(issues))
}
}
func TestEnginePullUsesPrelinkedExternalRefIdentifier(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
localRef := "https://linear.app/team/issue/TEAM-123/fix-login"
local := &types.Issue{
ID: "bd-linear-prelink",
Title: "Fix login",
Description: "Local draft",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr(localRef),
}
if err := store.CreateIssue(ctx, local, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
base := newMockTracker("linear")
base.issues = []TrackerIssue{{
ID: "linear-internal-123",
Identifier: "TEAM-123",
URL: "https://linear.app/team/issue/TEAM-123/renamed-login-fix",
Title: "Fix login",
Description: "Linear copy",
Priority: 2,
UpdatedAt: time.Now(),
}}
lt := &mockExternalRefTracker{
mockTracker: base,
buildRef: func(issue *TrackerIssue) string {
return "https://linear.app/team/issue/" + issue.Identifier
},
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ""
}
return strings.Split(parts[1], "/")[0]
},
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
}
engine := NewEngine(lt, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Fatalf("Sync() not successful: %s", result.Error)
}
if result.PullStats.Created != 0 || result.PullStats.Updated != 1 {
t.Fatalf("PullStats = %+v, want Created=0 Updated=1", result.PullStats)
}
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{ExternalRefContains: "TEAM-123"})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 1 {
t.Fatalf("issues linked to TEAM-123 = %d, want 1", len(issues))
}
got, err := store.GetIssue(ctx, local.ID)
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
wantRef := "https://linear.app/team/issue/TEAM-123"
if got.ExternalRef == nil || *got.ExternalRef != wantRef {
t.Fatalf("external_ref = %#v, want %q", got.ExternalRef, wantRef)
}
if got.Description != "Linear copy" {
t.Fatalf("description = %q, want Linear copy", got.Description)
}
}
func TestEnginePushOnly(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create a local issue
issue := &types.Issue{
ID: "bd-test1",
Title: "Local issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Errorf("Sync() not successful: %s", result.Error)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if result.PushStats.Created != 1 || result.PushStats.Updated != 0 {
t.Errorf("PushStats = %+v, want Created=1 Updated=0", result.PushStats)
}
if result.PullStats.Created != 0 || result.PullStats.Updated != 0 {
t.Errorf("PullStats = %+v, want zero value", result.PullStats)
}
if len(tracker.created) != 1 {
t.Errorf("tracker.created = %d, want 1", len(tracker.created))
}
}
func TestEnginePushUsesBatchTrackerWhenAvailable(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
ref := strPtr("https://notion.so/existing")
issues := []*types.Issue{
{ID: "bd-batch-1", Title: "Create me", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-batch-2", Title: "Update me", Status: types.StatusInProgress, IssueType: types.TypeFeature, Priority: 1, ExternalRef: ref},
}
for _, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
tracker := &mockBatchTracker{
mockTracker: newMockTracker("notion"),
batchResult: &BatchPushResult{
Created: []BatchPushItem{{LocalID: "bd-batch-1", ExternalRef: "https://notion.so/new-page"}},
Updated: []BatchPushItem{{LocalID: "bd-batch-2", ExternalRef: "https://notion.so/existing"}},
Warnings: []string{"Skipped unsupported Notion issue types: pm=1"},
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if tracker.batchCalls != 1 {
t.Fatalf("batchCalls = %d, want 1", tracker.batchCalls)
}
if len(tracker.created) != 0 || len(tracker.updated) != 0 {
t.Fatalf("fallback create/update path should not run: created=%d updated=%d", len(tracker.created), len(tracker.updated))
}
if result.PushStats.Created != 1 || result.PushStats.Updated != 1 {
t.Fatalf("PushStats = %+v", result.PushStats)
}
if len(result.Warnings) != 1 || !strings.Contains(result.Warnings[0], "pm=1") {
t.Fatalf("warnings = %#v", result.Warnings)
}
stored, err := store.GetIssue(ctx, "bd-batch-1")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if stored.ExternalRef == nil || *stored.ExternalRef != "https://notion.so/new-page" {
t.Fatalf("external_ref = %#v, want batch-created ref", stored.ExternalRef)
}
storedUpdated, err := store.GetIssue(ctx, "bd-batch-2")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if storedUpdated.ExternalRef == nil || *storedUpdated.ExternalRef != "https://notion.so/existing" {
t.Fatalf("updated external_ref = %#v, want batch-updated ref", storedUpdated.ExternalRef)
}
}
func TestEngineDryRunUsesBatchPreviewWhenAvailable(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue := &types.Issue{
ID: "bd-batch-preview",
Title: "Preview me",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://notion.so/existing"),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := &mockBatchTracker{
mockTracker: newMockTracker("notion"),
batchDryRun: &BatchPushResult{
Skipped: []string{"bd-batch-preview"},
Warnings: []string{"Skipped bd-batch-preview: Notion external_ref points outside the current target"},
},
}
engine := NewEngine(tracker, store, "test-actor")
var msgs []string
var warns []string
engine.OnMessage = func(msg string) { msgs = append(msgs, msg) }
engine.OnWarning = func(msg string) { warns = append(warns, msg) }
result, err := engine.Sync(ctx, SyncOptions{Push: true, DryRun: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if tracker.batchDryCalls != 1 {
t.Fatalf("batchDryCalls = %d, want 1", tracker.batchDryCalls)
}
if tracker.batchCalls != 0 {
t.Fatalf("batchCalls = %d, want 0", tracker.batchCalls)
}
if result.PushStats.Updated != 0 || result.PushStats.Created != 0 {
t.Fatalf("PushStats = %+v, want zero create/update", result.PushStats)
}
if len(result.Warnings) != 1 || !strings.Contains(result.Warnings[0], "outside the current target") {
t.Fatalf("warnings = %#v", result.Warnings)
}
if len(msgs) != 0 {
t.Fatalf("msgs = %#v, want no create/update preview lines", msgs)
}
if len(warns) != 0 {
t.Fatalf("warns = %#v, want no immediate warning spam", warns)
}
stored, err := store.GetIssue(ctx, "bd-batch-preview")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if stored.ExternalRef == nil || *stored.ExternalRef != "https://notion.so/existing" {
t.Fatalf("external_ref mutated in dry-run: %#v", stored.ExternalRef)
}
}
func TestEnginePushCountsCreateErrors(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue := &types.Issue{
ID: "bd-createerr1",
Title: "Local issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.createErr = fmt.Errorf("push response reported 1 error")
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 0 {
t.Errorf("Stats.Created = %d, want 0", result.Stats.Created)
}
if result.Stats.Errors != 1 {
t.Errorf("Stats.Errors = %d, want 1", result.Stats.Errors)
}
stored, err := store.GetIssue(ctx, "bd-createerr1")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if stored.ExternalRef != nil {
t.Fatalf("external_ref = %q, want nil", *stored.ExternalRef)
}
if len(tracker.created) != 0 {
t.Errorf("tracker.created = %d, want 0", len(tracker.created))
}
}
func TestEngineDryRun(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "Issue", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true, DryRun: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Errorf("Sync() not successful: %s", result.Error)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1 (dry-run counted)", result.Stats.Created)
}
// Verify nothing was actually stored
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 0 {
t.Errorf("stored %d issues in dry-run, want 0", len(issues))
}
}
func TestEnginePullMatchesExistingIssueByExternalIdentifier(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
externalRef := strPtr("https://www.notion.so/0123456789abcdef0123456789abcdef")
issue := &types.Issue{
ID: "bd-notion1",
Title: "Existing issue",
Description: "old description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: externalRef,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
base := newMockTracker("notion")
base.issues = []TrackerIssue{
{
ID: "01234567-89ab-cdef-0123-456789abcdef",
Identifier: "01234567-89ab-cdef-0123-456789abcdef",
URL: "https://www.notion.so/0123456789abcdef0123456789abcdef",
Title: "Existing issue updated",
Description: "new description",
UpdatedAt: time.Now(),
},
}
tracker := &mockExternalRefTracker{
mockTracker: base,
buildRef: func(issue *TrackerIssue) string { return issue.URL },
extract: func(ref string) string {
ref = strings.TrimSpace(ref)
if strings.HasPrefix(ref, "https://www.notion.so/") {
ref = strings.TrimPrefix(ref, "https://www.notion.so/")
}
return strings.ToLower(strings.ReplaceAll(ref, "-", ""))
},
isRef: func(ref string) bool { return strings.HasPrefix(ref, "https://www.notion.so/") },
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 0 {
t.Errorf("Stats.Created = %d, want 0", result.Stats.Created)
}
if result.Stats.Updated != 1 {
t.Errorf("Stats.Updated = %d, want 1", result.Stats.Updated)
}
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 1 {
t.Fatalf("stored issues = %d, want 1", len(issues))
}
if issues[0].ExternalRef == nil || *issues[0].ExternalRef != "https://www.notion.so/0123456789abcdef0123456789abcdef" {
t.Fatalf("external_ref = %v, want canonical url", issues[0].ExternalRef)
}
if issues[0].Title != "Existing issue updated" {
t.Fatalf("title = %q, want updated title", issues[0].Title)
}
}
func TestEngineDryRunCountsExistingIssuesAsUpdates(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
extRef := strPtr("https://notion.test/EXT-1")
issue := &types.Issue{
ID: "bd-existing1",
Title: "Existing issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: extRef,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("notion")
tracker.issues = []TrackerIssue{
{
ID: "EXT-1",
Identifier: "EXT-1",
URL: "https://notion.test/EXT-1",
Title: "Existing issue updated",
UpdatedAt: time.Now(),
},
}
var messages []string
engine := NewEngine(tracker, store, "test-actor")
engine.OnMessage = func(msg string) { messages = append(messages, msg) }
result, err := engine.Sync(ctx, SyncOptions{Pull: true, DryRun: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.PullStats.Created != 0 {
t.Errorf("PullStats.Created = %d, want 0", result.PullStats.Created)
}
if result.PullStats.Updated != 1 {
t.Errorf("PullStats.Updated = %d, want 1", result.PullStats.Updated)
}
joined := strings.Join(messages, "\n")
if strings.Contains(joined, "Would import") {
t.Fatalf("messages = %q, want update preview without import", joined)
}
if !strings.Contains(joined, "Would update local issue") {
t.Fatalf("messages = %q, want update preview", joined)
}
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 1 {
t.Fatalf("stored issues = %d, want 1", len(issues))
}
}
func TestEngineExcludeTypes(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create issues of different types
for _, tc := range []struct {
id string
typ types.IssueType
}{
{"bd-task1", types.TypeTask},
{"bd-bug1", types.TypeBug},
{"bd-feat1", types.TypeFeature},
} {
issue := &types.Issue{
ID: tc.id,
Title: "Issue " + tc.id,
Status: types.StatusOpen,
IssueType: tc.typ,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", tc.id, err)
}
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
// Push excluding bugs
result, err := engine.Sync(ctx, SyncOptions{Push: true, ExcludeTypes: []types.IssueType{types.TypeBug}})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Errorf("Sync() not successful: %s", result.Error)
}
if len(tracker.created) != 2 {
t.Errorf("created %d issues (excluding bugs), want 2", len(tracker.created))
}
}
func TestEngineConflictResolution(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Set up last_sync (use UTC to avoid DATETIME timezone round-trip issues)
lastSync := time.Now().UTC().Add(-1 * time.Hour)
if err := store.SetConfig(ctx, "test.last_sync", lastSync.Format(time.RFC3339)); err != nil {
t.Fatalf("SetConfig() error: %v", err)
}
// Create a local issue that was modified after last_sync
issue := &types.Issue{
ID: "bd-conflict1",
Title: "Local version",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://test.test/EXT-1"),
UpdatedAt: time.Now().UTC().Add(-30 * time.Minute), // Modified 30 min ago
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
// Set up tracker with an external issue also modified after last_sync
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{
ID: "EXT-1",
Identifier: "EXT-1",
Title: "External version",
UpdatedAt: time.Now().UTC().Add(-15 * time.Minute), // Modified 15 min ago (newer)
},
}
engine := NewEngine(tracker, store, "test-actor")
// Detect conflicts
conflicts, err := engine.DetectConflicts(ctx)
if err != nil {
t.Fatalf("DetectConflicts() error: %v", err)
}
if len(conflicts) != 1 {
t.Fatalf("detected %d conflicts, want 1", len(conflicts))
}
if conflicts[0].IssueID != "bd-conflict1" {
t.Errorf("conflict issue ID = %q, want %q", conflicts[0].IssueID, "bd-conflict1")
}
}
func TestEngineSyncDoesNotCreateFalseConflictsAfterPull(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
lastSync := time.Now().UTC().Add(-1 * time.Hour)
if err := store.SetConfig(ctx, "test.last_sync", lastSync.Format(time.RFC3339)); err != nil {
t.Fatalf("SetConfig() error: %v", err)
}
issue := &types.Issue{
ID: "bd-sync1",
Title: "Local title",
Description: "Local description",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://test.test/EXT-1"),
UpdatedAt: lastSync.Add(-10 * time.Minute),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{
ID: "EXT-1",
Identifier: "EXT-1",
URL: "https://test.test/EXT-1",
Title: "Remote title",
Description: "Remote description",
UpdatedAt: lastSync.Add(30 * time.Minute),
},
}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true, Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Conflicts != 0 {
t.Fatalf("conflicts = %d, want 0", result.Stats.Conflicts)
}
if len(tracker.updated) != 0 {
t.Fatalf("tracker.updated = %d, want 0", len(tracker.updated))
}
stored, err := store.GetIssue(ctx, "bd-sync1")
if err != nil {
t.Fatalf("GetIssue() error: %v", err)
}
if stored.Title != "Remote title" {
t.Fatalf("title = %q, want remote title", stored.Title)
}
}
func TestEnginePullWithShouldImport(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "Keep this", UpdatedAt: time.Now()},
{ID: "2", Identifier: "TEST-2", Title: "Skip this", UpdatedAt: time.Now()},
{ID: "3", Identifier: "TEST-3", Title: "Keep this too", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
engine.PullHooks = &PullHooks{
ShouldImport: func(issue *TrackerIssue) bool {
return issue.Title != "Skip this"
},
}
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 2 {
t.Errorf("Stats.Created = %d, want 2", result.Stats.Created)
}
if result.Stats.Skipped != 1 {
t.Errorf("Stats.Skipped = %d, want 1", result.Stats.Skipped)
}
issues, _ := store.SearchIssues(ctx, "", types.IssueFilter{})
if len(issues) != 2 {
t.Errorf("stored %d issues, want 2", len(issues))
}
}
func TestEnginePullWithTransformHook(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "Issue one", Description: "raw desc", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
engine.PullHooks = &PullHooks{
TransformIssue: func(issue *types.Issue) {
issue.Description = "transformed: " + issue.Description
},
}
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
issues, _ := store.SearchIssues(ctx, "", types.IssueFilter{})
if len(issues) != 1 {
t.Fatalf("stored %d issues, want 1", len(issues))
}
if issues[0].Description != "transformed: raw desc" {
t.Errorf("description = %q, want %q", issues[0].Description, "transformed: raw desc")
}
}
func TestEnginePullWithGenerateID(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "Issue one", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
engine.PullHooks = &PullHooks{
GenerateID: func(_ context.Context, issue *types.Issue) error {
issue.ID = "bd-custom-id-123"
return nil
},
}
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
// Verify the custom ID was used
issues, _ := store.SearchIssues(ctx, "", types.IssueFilter{})
if len(issues) != 1 {
t.Fatalf("stored %d issues, want 1", len(issues))
}
if issues[0].ID != "bd-custom-id-123" {
t.Errorf("issue ID = %q, want %q", issues[0].ID, "bd-custom-id-123")
}
}
func TestEnginePullWithGenerateIDError(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{ID: "1", Identifier: "TEST-1", Title: "Good issue", UpdatedAt: time.Now()},
{ID: "2", Identifier: "TEST-2", Title: "Bad issue", UpdatedAt: time.Now()},
}
engine := NewEngine(tracker, store, "test-actor")
engine.PullHooks = &PullHooks{
GenerateID: func(_ context.Context, issue *types.Issue) error {
if issue.Title == "Bad issue" {
return fmt.Errorf("collision detected")
}
issue.ID = "bd-good-1"
return nil
},
}
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if result.Stats.Skipped != 1 {
t.Errorf("Stats.Skipped = %d, want 1 (GenerateID error should skip)", result.Stats.Skipped)
}
}
func TestEnginePushWithFormatDescription(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue := &types.Issue{
ID: "bd-fmt1",
Title: "Issue with design",
Description: "Base description",
Design: "Some design notes",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
engine.PushHooks = &PushHooks{
FormatDescription: func(issue *types.Issue) string {
return issue.Description + "\n\n## Design\n" + issue.Design
},
}
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if len(tracker.created) != 1 {
t.Fatalf("tracker.created = %d, want 1", len(tracker.created))
}
// The issue sent to the tracker should have the formatted description
if tracker.created[0].Description != "Base description\n\n## Design\nSome design notes" {
t.Errorf("pushed description = %q, want formatted version", tracker.created[0].Description)
}
// Verify the local issue was NOT mutated
localIssue, _ := store.GetIssue(ctx, "bd-fmt1")
if localIssue.Description != "Base description" {
t.Errorf("local description was mutated to %q, should still be %q", localIssue.Description, "Base description")
}
}
func TestEnginePushWithShouldPush(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create two local issues
for _, tc := range []struct {
id string
title string
}{
{"bd-push1", "Push this"},
{"bd-skip1", "Skip this"},
} {
issue := &types.Issue{
ID: tc.id,
Title: tc.title,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", tc.id, err)
}
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
engine.PushHooks = &PushHooks{
ShouldPush: func(issue *types.Issue) bool {
return !strings.HasPrefix(issue.ID, "bd-skip")
},
}
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if len(tracker.created) != 1 {
t.Errorf("tracker.created = %d, want 1", len(tracker.created))
}
}
func TestEnginePushWithShouldPushCanInspectLabels(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
for _, tc := range []struct {
id string
title string
label string
}{
{id: "bd-labelpush1", title: "Push labeled", label: "notion-sync"},
{id: "bd-labelskip1", title: "Skip unlabeled"},
} {
issue := &types.Issue{
ID: tc.id,
Title: tc.title,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", tc.id, err)
}
if tc.label != "" {
if err := store.AddLabel(ctx, tc.id, tc.label, "test-actor"); err != nil {
t.Fatalf("AddLabel(%s) error: %v", tc.id, err)
}
}
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
engine.PushHooks = &PushHooks{
ShouldPush: func(issue *types.Issue) bool {
for _, label := range issue.Labels {
if label == "notion-sync" {
return true
}
}
return false
},
}
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if len(tracker.created) != 1 {
t.Fatalf("tracker.created = %d, want 1", len(tracker.created))
}
if tracker.created[0].ID != "bd-labelpush1" {
t.Fatalf("pushed issue ID = %q, want bd-labelpush1", tracker.created[0].ID)
}
}
func TestEngineDryRunTreatsForeignExternalRefAsCreate(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
foreignRef := "https://github.com/example/repo/issues/1"
issue := &types.Issue{
ID: "bd-foreign1",
Title: "Mirror me to Notion",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: &foreignRef,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := &mockExternalRefTracker{
mockTracker: newMockTracker("notion"),
isRef: func(ref string) bool { return strings.Contains(ref, "notion.so") },
}
engine := NewEngine(tracker, store, "test-actor")
var msgs []string
engine.OnMessage = func(msg string) { msgs = append(msgs, msg) }
result, err := engine.Sync(ctx, SyncOptions{Push: true, DryRun: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Fatalf("Stats.Created = %d, want 1", result.Stats.Created)
}
if result.Stats.Updated != 0 {
t.Fatalf("Stats.Updated = %d, want 0", result.Stats.Updated)
}
joined := strings.Join(msgs, "\n")
if !strings.Contains(joined, "Would create in notion: Mirror me to Notion") {
t.Fatalf("messages = %q, want create message", joined)
}
if strings.Contains(joined, "Would update in notion") {
t.Fatalf("messages = %q, did not expect update message", joined)
}
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
if err != nil {
t.Fatalf("SearchIssues() error: %v", err)
}
if len(issues) != 1 {
t.Fatalf("stored issues = %d, want 1", len(issues))
}
if issues[0].ExternalRef == nil || *issues[0].ExternalRef != foreignRef {
t.Fatalf("external_ref = %v, want %q", issues[0].ExternalRef, foreignRef)
}
}
func TestEnginePushWithContentEqual(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create a local issue that already exists externally
issue := &types.Issue{
ID: "bd-eq1",
Title: "Identical content",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://test.test/EXT-EQ1"),
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{
ID: "EXT-EQ1",
Identifier: "EXT-EQ1",
Title: "Identical content",
UpdatedAt: time.Now().Add(-1 * time.Hour), // older, would normally trigger update
},
}
engine := NewEngine(tracker, store, "test-actor")
engine.PushHooks = &PushHooks{
ContentEqual: func(local *types.Issue, remote *TrackerIssue) bool {
// Content-hash dedup: titles match = identical
return local.Title == remote.Title
},
}
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
// Should be skipped because ContentEqual returns true
if result.Stats.Updated != 0 {
t.Errorf("Stats.Updated = %d, want 0 (content equal should skip)", result.Stats.Updated)
}
if len(tracker.updated) != 0 {
t.Errorf("tracker.updated = %d, want 0", len(tracker.updated))
}
}
func TestEnginePushExcludeEphemeral(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create a normal issue and an ephemeral one
normal := &types.Issue{
ID: "bd-normal1",
Title: "Normal issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
ephemeral := &types.Issue{
ID: "bd-wisp-eph1",
Title: "Ephemeral wisp",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
Ephemeral: true,
}
if err := store.CreateIssue(ctx, normal, "test-actor"); err != nil {
t.Fatalf("CreateIssue(normal) error: %v", err)
}
if err := store.CreateIssue(ctx, ephemeral, "test-actor"); err != nil {
t.Fatalf("CreateIssue(ephemeral) error: %v", err)
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
// With ExcludeEphemeral: only the normal issue should be pushed
result, err := engine.Sync(ctx, SyncOptions{Push: true, ExcludeEphemeral: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
if len(tracker.created) != 1 {
t.Errorf("tracker.created = %d, want 1", len(tracker.created))
}
if tracker.created[0].Title != "Normal issue" {
t.Errorf("pushed issue title = %q, want %q", tracker.created[0].Title, "Normal issue")
}
}
func TestEnginePushWithStateCache(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue := &types.Issue{
ID: "bd-state1",
Title: "Issue with state",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue() error: %v", err)
}
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
buildCacheCalled := false
engine.PushHooks = &PushHooks{
BuildStateCache: func(ctx context.Context) (interface{}, error) {
buildCacheCalled = true
return map[types.Status]string{
types.StatusOpen: "state-open-id",
types.StatusClosed: "state-closed-id",
}, nil
},
ResolveState: func(cache interface{}, status types.Status) (string, bool) {
m := cache.(map[types.Status]string)
id, ok := m[status]
return id, ok
},
}
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !buildCacheCalled {
t.Error("BuildStateCache was not called")
}
if result.Stats.Created != 1 {
t.Errorf("Stats.Created = %d, want 1", result.Stats.Created)
}
// Verify ResolveState works via the Engine method
stateID, ok := engine.ResolveState(types.StatusOpen)
if !ok || stateID != "state-open-id" {
t.Errorf("ResolveState(Open) = (%q, %v), want (%q, true)", stateID, ok, "state-open-id")
}
stateID, ok = engine.ResolveState(types.StatusClosed)
if !ok || stateID != "state-closed-id" {
t.Errorf("ResolveState(Closed) = (%q, %v), want (%q, true)", stateID, ok, "state-closed-id")
}
}
// --- ParentID filter tests ---
func TestEnginePushWithParentFilterBasic(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
parent := &types.Issue{ID: "bd-par1", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
child1 := &types.Issue{ID: "bd-ch1", Title: "Child 1", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
child2 := &types.Issue{ID: "bd-ch2", Title: "Child 2", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
unrelated := &types.Issue{ID: "bd-unrel1", Title: "Unrelated", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
for _, issue := range []*types.Issue{parent, child1, child2, unrelated} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
for _, childID := range []string{"bd-ch1", "bd-ch2"} {
dep := &types.Dependency{IssueID: childID, DependsOnID: "bd-par1", Type: types.DepParentChild}
if err := store.AddDependency(ctx, dep, "test-actor"); err != nil {
t.Fatalf("AddDependency(%s) error: %v", childID, err)
}
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true, ParentID: "bd-par1"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Errorf("Sync() not successful: %s", result.Error)
}
if len(tk.created) != 3 {
t.Errorf("pushed %d issues, want 3 (parent + 2 children)", len(tk.created))
}
for _, pushed := range tk.created {
if strings.Contains(pushed.Title, "Unrelated") {
t.Errorf("unrelated issue was pushed")
}
}
}
func TestEnginePushWithParentFilterDoesNotUpdateOrphanExternalIssues(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
parent := &types.Issue{ID: "bd-par-orphan", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
child := &types.Issue{ID: "bd-child-orphan", Title: "Canceled upstream title", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
for _, issue := range []*types.Issue{parent, child} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
dep := &types.Dependency{IssueID: "bd-child-orphan", DependsOnID: "bd-par-orphan", Type: types.DepParentChild}
if err := store.AddDependency(ctx, dep, "test-actor"); err != nil {
t.Fatalf("AddDependency error: %v", err)
}
// Simulate an orphan external issue with an overlapping title. Current push
// must ignore it because no local Linear external_ref claims ownership.
tk := newMockTracker("linear")
tk.issues = []TrackerIssue{
{
ID: "linear-1",
Identifier: "LIN-1",
Title: "Canceled upstream title",
UpdatedAt: time.Now().UTC(),
},
}
engine := NewEngine(tk, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true, ParentID: "bd-par-orphan"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if !result.Success {
t.Fatalf("Sync() not successful: %s", result.Error)
}
if len(tk.updated) != 0 {
t.Fatalf("updated %d external issues, want 0", len(tk.updated))
}
if len(tk.created) != 2 {
t.Fatalf("created %d issues, want 2 (parent + child)", len(tk.created))
}
}
func TestEnginePushWithParentFilterDeep(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// parent → child → grandchild; unrelated is separate
for _, issue := range []*types.Issue{
{ID: "bd-dep1", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-dch1", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-dgc1", Title: "Grandchild", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-dunrel1", Title: "Unrelated", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
for _, d := range []struct{ child, parent string }{
{"bd-dch1", "bd-dep1"},
{"bd-dgc1", "bd-dch1"},
} {
dep := &types.Dependency{IssueID: d.child, DependsOnID: d.parent, Type: types.DepParentChild}
if err := store.AddDependency(ctx, dep, "test-actor"); err != nil {
t.Fatalf("AddDependency error: %v", err)
}
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
_, err := engine.Sync(ctx, SyncOptions{Push: true, ParentID: "bd-dep1"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if len(tk.created) != 3 {
t.Errorf("pushed %d issues, want 3 (parent + child + grandchild)", len(tk.created))
}
}
func TestEnginePushWithParentFilterLeaf(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
for _, issue := range []*types.Issue{
{ID: "bd-leaf1", Title: "Leaf", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-lother1", Title: "Other", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true, ParentID: "bd-leaf1"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if len(tk.created) != 1 {
t.Errorf("pushed %d issues, want 1 (leaf only)", len(tk.created))
}
if result.Stats.Skipped != 1 {
t.Errorf("Stats.Skipped = %d, want 1", result.Stats.Skipped)
}
}
func TestEnginePushWithParentFilterNonParentChildIgnored(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// "blocks" dep should not be followed — only parent-child edges count.
for _, issue := range []*types.Issue{
{ID: "bd-fp1", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-fbl1", Title: "Blocked", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
dep := &types.Dependency{IssueID: "bd-fp1", DependsOnID: "bd-fbl1", Type: types.DepBlocks}
if err := store.AddDependency(ctx, dep, "test-actor"); err != nil {
t.Fatalf("AddDependency error: %v", err)
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
_, err := engine.Sync(ctx, SyncOptions{Push: true, ParentID: "bd-fp1"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if len(tk.created) != 1 {
t.Errorf("pushed %d issues, want 1 (blocks deps must not be followed)", len(tk.created))
}
if tk.created[0].Title != "Parent" {
t.Errorf("pushed %q, want Parent", tk.created[0].Title)
}
}
func TestEnginePushWithParentFilterEmptyMeansAll(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
for i, title := range []string{"Issue A", "Issue B", "Issue C"} {
issue := &types.Issue{
ID: fmt.Sprintf("bd-all%d", i+1),
Title: title,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
_, err := engine.Sync(ctx, SyncOptions{Push: true}) // no ParentID
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if len(tk.created) != 3 {
t.Errorf("pushed %d issues, want 3 (no parent filter)", len(tk.created))
}
}
func TestEnginePushWithParentFilterDryRun(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
for _, issue := range []*types.Issue{
{ID: "bd-drp1", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-drc1", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-dro1", Title: "Other", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", issue.ID, err)
}
}
dep := &types.Dependency{IssueID: "bd-drc1", DependsOnID: "bd-drp1", Type: types.DepParentChild}
if err := store.AddDependency(ctx, dep, "test-actor"); err != nil {
t.Fatalf("AddDependency error: %v", err)
}
tk := newMockTracker("test")
engine := NewEngine(tk, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true, DryRun: true, ParentID: "bd-drp1"})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
if result.Stats.Created != 2 {
t.Errorf("dry-run Stats.Created = %d, want 2", result.Stats.Created)
}
if len(tk.created) != 0 {
t.Errorf("dry-run sent %d issues to tracker, want 0", len(tk.created))
}
}
func TestEnginePushPartialFailure(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create 3 local issues
for i, id := range []string{"bd-pf1", "bd-pf2", "bd-pf3"} {
issue := &types.Issue{
ID: id,
Title: fmt.Sprintf("Partial failure issue %d", i+1),
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", id, err)
}
}
tracker := newMockTracker("test")
tracker.createFailAfter = 2
tracker.createErr = fmt.Errorf("rate limit exceeded")
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
// Partial failure doesn't abort the sync
if !result.Success {
t.Errorf("Sync() should succeed on partial failure, got Success=false: %s", result.Error)
}
if result.Stats.Created != 2 {
t.Errorf("Stats.Created = %d, want 2", result.Stats.Created)
}
if result.Stats.Errors != 1 {
t.Errorf("Stats.Errors = %d, want 1", result.Stats.Errors)
}
// Warnings should contain the failure message
if len(result.Warnings) == 0 {
t.Fatal("expected warnings for partial failure, got none")
}
found := false
for _, w := range result.Warnings {
if strings.Contains(w, "rate limit exceeded") {
found = true
break
}
}
if !found {
t.Errorf("expected warning containing 'rate limit exceeded', got: %v", result.Warnings)
}
}
func TestEngineSyncCollectsWarnings(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create 2 local issues — one will succeed, one will fail
for _, tc := range []struct {
id string
title string
}{
{"bd-warn1", "Succeeds"},
{"bd-warn2", "Fails"},
} {
issue := &types.Issue{
ID: tc.id,
Title: tc.title,
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue(%s) error: %v", tc.id, err)
}
}
tracker := newMockTracker("test")
tracker.createFailAfter = 1
tracker.createErr = fmt.Errorf("API timeout")
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Push: true})
if err != nil {
t.Fatalf("Sync() error: %v", err)
}
// result.Warnings should be non-nil and contain the failure message
if result.Warnings == nil {
t.Fatal("result.Warnings is nil, expected warning messages")
}
if len(result.Warnings) == 0 {
t.Fatal("result.Warnings is empty, expected at least one warning")
}
found := false
for _, w := range result.Warnings {
if strings.Contains(w, "API timeout") {
found = true
break
}
}
if !found {
t.Errorf("expected warning containing 'API timeout', got: %v", result.Warnings)
}
}
func TestEngineCreateDependencies(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
// Create two issues that will be the dependency endpoints
issue1 := &types.Issue{
ID: "bd-dep1",
Title: "Dependency source",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
issue2 := &types.Issue{
ID: "bd-dep2",
Title: "Dependency target",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
for _, issue := range []*types.Issue{issue1, issue2} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
// Set external refs so GetIssueByExternalRef can find them
store.UpdateIssue(ctx, issue1.ID, map[string]interface{}{"external_ref": "https://test.test/EXT-1"}, "test-actor")
store.UpdateIssue(ctx, issue2.ID, map[string]interface{}{"external_ref": "https://test.test/EXT-2"}, "test-actor")
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
// Valid dependency
deps := []DependencyInfo{
{FromExternalID: "https://test.test/EXT-1", ToExternalID: "https://test.test/EXT-2", Type: string(types.DepBlocks)},
}
errCount := engine.createDependencies(ctx, deps)
if errCount != 0 {
t.Errorf("createDependencies returned errCount=%d, want 0", errCount)
}
// Verify dependency was actually created
depRecords, err := store.GetDependencyRecords(ctx, issue1.ID)
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) == 0 {
t.Fatal("expected at least one dependency record, got none")
}
}
func TestEngineCreateDependenciesResolvesExternalIdentifiers(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue1 := &types.Issue{
ID: "bd-linear-blocked",
Title: "Blocked issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
issue2 := &types.Issue{
ID: "bd-linear-blocker",
Title: "Blocker issue",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
}
for _, issue := range []*types.Issue{issue1, issue2} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
if err := store.UpdateIssue(ctx, issue1.ID, map[string]interface{}{"external_ref": "https://linear.app/team/issue/TEAM-101/blocked-issue"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue issue1 external_ref: %v", err)
}
if err := store.UpdateIssue(ctx, issue2.ID, map[string]interface{}{"external_ref": "https://linear.app/team/issue/TEAM-100/blocker-issue"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue issue2 external_ref: %v", err)
}
engine := NewEngine(&mockExternalRefTracker{
mockTracker: newMockTracker("linear"),
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app")
},
extract: func(ref string) string {
parts := strings.Split(ref, "/")
for _, part := range parts {
if strings.HasPrefix(part, "TEAM-") {
return part
}
}
return ref
},
}, store, "test-actor")
deps := []DependencyInfo{
{FromExternalID: "TEAM-101", ToExternalID: "TEAM-100", Type: string(types.DepBlocks)},
}
errCount := engine.createDependencies(ctx, deps)
if errCount != 0 {
t.Errorf("createDependencies returned errCount=%d, want 0; warnings=%v", errCount, engine.warnings)
}
depRecords, err := store.GetDependencyRecords(ctx, issue1.ID)
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 {
t.Fatalf("expected 1 dependency record, got %d", len(depRecords))
}
if depRecords[0].DependsOnID != issue2.ID || depRecords[0].Type != types.DepBlocks {
t.Errorf("dependency = %s -> %s (%s), want %s -> %s (%s)",
depRecords[0].IssueID, depRecords[0].DependsOnID, depRecords[0].Type,
issue1.ID, issue2.ID, types.DepBlocks)
}
}
func TestEngineCreateDependenciesResolvesBareIdentifierFromExternalRef(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issues := []*types.Issue{
{ID: "bd-linear-child", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-linear-parent", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
}
for _, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
if err := store.UpdateIssue(ctx, "bd-linear-child", map[string]interface{}{"external_ref": "https://linear.app/team/issue/TEAM-101/child-title"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue child external_ref: %v", err)
}
if err := store.UpdateIssue(ctx, "bd-linear-parent", map[string]interface{}{"external_ref": "https://linear.app/team/issue/TEAM-100/parent-title"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue parent external_ref: %v", err)
}
base := newMockTracker("linear")
lt := &mockExternalRefTracker{
mockTracker: base,
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ref
}
return strings.Split(parts[1], "/")[0]
},
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
}
engine := NewEngine(lt, store, "test-actor")
errCount := engine.createDependencies(ctx, []DependencyInfo{
{FromExternalID: "TEAM-101", ToExternalID: "TEAM-100", Type: string(types.DepParentChild)},
})
if errCount != 0 {
t.Fatalf("createDependencies returned errCount=%d, warnings=%v", errCount, engine.warnings)
}
depRecords, err := store.GetDependencyRecords(ctx, "bd-linear-child")
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 {
t.Fatalf("expected 1 dependency record, got %d", len(depRecords))
}
if depRecords[0].DependsOnID != "bd-linear-parent" || depRecords[0].Type != types.DepParentChild {
t.Fatalf("dependency = %s -> %s (%s), want bd-linear-child -> bd-linear-parent (%s)",
depRecords[0].IssueID, depRecords[0].DependsOnID, depRecords[0].Type, types.DepParentChild)
}
}
func TestEngineCreateDependenciesResolvesSyntheticExternalRef(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issues := []*types.Issue{
{ID: "bd-linear-child", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-linear-milestone", Title: "Milestone", Status: types.StatusOpen, IssueType: types.TypeEpic, Priority: 2},
}
for _, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
if err := store.UpdateIssue(ctx, "bd-linear-child", map[string]interface{}{"external_ref": "https://linear.app/team/issue/TEAM-101/child-title"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue child external_ref: %v", err)
}
if err := store.UpdateIssue(ctx, "bd-linear-milestone", map[string]interface{}{"external_ref": "linear:project-milestone:milestone-1"}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue milestone external_ref: %v", err)
}
lt := &mockExternalRefTracker{
mockTracker: newMockTracker("linear"),
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ref
}
return strings.Split(parts[1], "/")[0]
},
}
engine := NewEngine(lt, store, "test-actor")
errCount := engine.createDependencies(ctx, []DependencyInfo{
{
FromExternalID: "https://linear.app/team/issue/TEAM-101",
ToExternalID: "linear:project-milestone:milestone-1",
Type: string(types.DepParentChild),
},
})
if errCount != 0 {
t.Fatalf("createDependencies returned errCount=%d, warnings=%v", errCount, engine.warnings)
}
depRecords, err := store.GetDependencyRecords(ctx, "bd-linear-child")
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 {
t.Fatalf("expected 1 dependency record, got %d", len(depRecords))
}
if depRecords[0].DependsOnID != "bd-linear-milestone" || depRecords[0].Type != types.DepParentChild {
t.Fatalf("dependency = %s -> %s (%s), want bd-linear-child -> bd-linear-milestone (%s)",
depRecords[0].IssueID, depRecords[0].DependsOnID, depRecords[0].Type, types.DepParentChild)
}
}
func TestEnginePullCreatesDependenciesForUnchangedIssues(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue1 := &types.Issue{ID: "bd-unchanged-1", Title: "Blocked issue", Description: "already pulled", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
issue2 := &types.Issue{ID: "bd-unchanged-2", Title: "Blocker issue", Description: "already pulled", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
for _, issue := range []*types.Issue{issue1, issue2} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
ref := fmt.Sprintf("https://test.test/EXT-%s", strings.TrimPrefix(issue.ID, "bd-unchanged-"))
if err := store.UpdateIssue(ctx, issue.ID, map[string]interface{}{"external_ref": ref}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref: %v", err)
}
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{Identifier: "EXT-1", Title: issue1.Title, Description: issue1.Description},
{Identifier: "EXT-2", Title: issue2.Title, Description: issue2.Description},
}
tracker.fieldMapper = &mockMapper{issueToBeads: func(ti *TrackerIssue) *IssueConversion {
conv := (&mockMapper{}).IssueToBeads(ti)
if ti.Identifier == "EXT-1" {
conv.Dependencies = []DependencyInfo{
{FromExternalID: "EXT-1", ToExternalID: "EXT-2", Type: string(types.DepBlocks)},
}
}
return conv
}}
engine := NewEngine(tracker, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync error: %v", err)
}
if result.PullStats.Updated != 0 || result.PullStats.Created != 0 {
t.Fatalf("PullStats = %+v, want only skipped unchanged issues", result.PullStats)
}
depRecords, err := store.GetDependencyRecords(ctx, issue1.ID)
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 || depRecords[0].DependsOnID != issue2.ID {
t.Fatalf("dependency records = %+v, want %s -> %s", depRecords, issue1.ID, issue2.ID)
}
}
func TestEnginePullDoesNotCreateDependenciesForLocallyModifiedSkippedIssue(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
lastSync := time.Now().UTC().Add(-1 * time.Hour)
if err := store.SetLocalMetadata(ctx, "test.last_sync", lastSync.Format(time.RFC3339)); err != nil {
t.Fatalf("SetLocalMetadata error: %v", err)
}
child := &types.Issue{
ID: "bd-local-child",
Title: "Local child",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://test.test/EXT-1"),
CreatedAt: lastSync.Add(-2 * time.Hour),
UpdatedAt: lastSync.Add(30 * time.Minute),
}
parent := &types.Issue{
ID: "bd-local-parent",
Title: "Parent",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr("https://test.test/EXT-2"),
CreatedAt: lastSync.Add(-2 * time.Hour),
UpdatedAt: lastSync.Add(-30 * time.Minute),
}
for _, issue := range []*types.Issue{child, parent} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{Identifier: "EXT-1", Title: "Remote child", UpdatedAt: lastSync.Add(10 * time.Minute)},
{Identifier: "EXT-2", Title: "Parent", UpdatedAt: lastSync.Add(10 * time.Minute)},
}
tracker.fieldMapper = &mockMapper{issueToBeads: func(ti *TrackerIssue) *IssueConversion {
conv := (&mockMapper{}).IssueToBeads(ti)
if ti.Identifier == "EXT-1" {
conv.Dependencies = []DependencyInfo{
{FromExternalID: "EXT-1", ToExternalID: "EXT-2", Type: string(types.DepBlocks)},
}
}
return conv
}}
engine := NewEngine(tracker, store, "test-actor")
if _, err := engine.Sync(ctx, SyncOptions{Pull: true}); err != nil {
t.Fatalf("Sync error: %v", err)
}
depRecords, err := store.GetDependencyRecords(ctx, child.ID)
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 0 {
t.Fatalf("dependency records = %+v, want none for locally modified skipped issue", depRecords)
}
}
func TestEnginePullDryRunPreviewsDependencies(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issue1 := &types.Issue{ID: "bd-dry-child", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
issue2 := &types.Issue{ID: "bd-dry-blocker", Title: "Blocker", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2}
for _, issue := range []*types.Issue{issue1, issue2} {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
ref := "https://test.test/EXT-2"
if issue.ID == "bd-dry-child" {
ref = "https://test.test/EXT-1"
}
if err := store.UpdateIssue(ctx, issue.ID, map[string]interface{}{"external_ref": ref}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref: %v", err)
}
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{Identifier: "EXT-1", Title: issue1.Title},
{Identifier: "EXT-2", Title: issue2.Title},
}
tracker.fieldMapper = &mockMapper{issueToBeads: func(ti *TrackerIssue) *IssueConversion {
conv := (&mockMapper{}).IssueToBeads(ti)
if ti.Identifier == "EXT-1" {
conv.Dependencies = []DependencyInfo{
{FromExternalID: "EXT-1", ToExternalID: "EXT-2", Type: string(types.DepBlocks)},
}
}
return conv
}}
var messages []string
engine := NewEngine(tracker, store, "test-actor")
engine.OnMessage = func(msg string) { messages = append(messages, msg) }
if _, err := engine.Sync(ctx, SyncOptions{Pull: true, DryRun: true}); err != nil {
t.Fatalf("Sync error: %v", err)
}
depRecords, err := store.GetDependencyRecords(ctx, issue1.ID)
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 0 {
t.Fatalf("dependency records = %+v, want none in dry-run", depRecords)
}
found := false
for _, msg := range messages {
if strings.Contains(msg, "Would create 1 dependencies") {
found = true
break
}
}
if !found {
t.Fatalf("dry-run messages = %v, want dependency summary", messages)
}
}
func TestEnginePullFiltersDependencyTypes(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issues := []*types.Issue{
{ID: "bd-filter-child", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-filter-parent", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-filter-blocker", Title: "Blocker", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
}
for i, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
ref := fmt.Sprintf("https://test.test/EXT-%d", i+1)
if err := store.UpdateIssue(ctx, issue.ID, map[string]interface{}{"external_ref": ref}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref: %v", err)
}
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{Identifier: "EXT-1", Title: "Child"},
{Identifier: "EXT-2", Title: "Parent"},
{Identifier: "EXT-3", Title: "Blocker"},
}
tracker.fieldMapper = &mockMapper{issueToBeads: func(ti *TrackerIssue) *IssueConversion {
conv := (&mockMapper{}).IssueToBeads(ti)
if ti.Identifier == "EXT-1" {
conv.Dependencies = []DependencyInfo{
{FromExternalID: "EXT-1", ToExternalID: "EXT-2", Type: string(types.DepParentChild)},
{FromExternalID: "EXT-1", ToExternalID: "EXT-3", Type: string(types.DepBlocks)},
}
}
return conv
}}
engine := NewEngine(tracker, store, "test-actor")
if _, err := engine.Sync(ctx, SyncOptions{
Pull: true,
DependencyTypes: []types.DependencyType{types.DepParentChild},
}); err != nil {
t.Fatalf("Sync error: %v", err)
}
depRecords, err := store.GetDependencyRecords(ctx, "bd-filter-child")
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 {
t.Fatalf("expected 1 dependency record, got %d: %+v", len(depRecords), depRecords)
}
if depRecords[0].DependsOnID != "bd-filter-parent" || depRecords[0].Type != types.DepParentChild {
t.Fatalf("dependency = %s -> %s (%s), want bd-filter-child -> bd-filter-parent (%s)",
depRecords[0].IssueID, depRecords[0].DependsOnID, depRecords[0].Type, types.DepParentChild)
}
}
func TestEnginePullFiltersLinearRelationsBySource(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issues := []*types.Issue{
{ID: "bd-source-child", Title: "Child", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-source-parent", Title: "Parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-source-related-parent", Title: "Related parent", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
}
for i, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
ref := fmt.Sprintf("https://test.test/EXT-SRC-%d", i+1)
if err := store.UpdateIssue(ctx, issue.ID, map[string]interface{}{"external_ref": ref}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref: %v", err)
}
}
tracker := newMockTracker("test")
tracker.issues = []TrackerIssue{
{Identifier: "EXT-SRC-1", Title: "Child"},
{Identifier: "EXT-SRC-2", Title: "Parent"},
{Identifier: "EXT-SRC-3", Title: "Related parent"},
}
tracker.fieldMapper = &mockMapper{issueToBeads: func(ti *TrackerIssue) *IssueConversion {
conv := (&mockMapper{}).IssueToBeads(ti)
if ti.Identifier == "EXT-SRC-1" {
conv.Dependencies = []DependencyInfo{
{
FromExternalID: "EXT-SRC-1",
ToExternalID: "EXT-SRC-2",
Type: string(types.DepParentChild),
Source: DependencySourceParent,
},
{
FromExternalID: "EXT-SRC-1",
ToExternalID: "EXT-SRC-3",
Type: string(types.DepParentChild),
Source: DependencySourceRelation,
},
}
}
return conv
}}
engine := NewEngine(tracker, store, "test-actor")
if _, err := engine.Sync(ctx, SyncOptions{
Pull: true,
DependencySources: []DependencySource{DependencySourceParent},
}); err != nil {
t.Fatalf("Sync error: %v", err)
}
depRecords, err := store.GetDependencyRecords(ctx, "bd-source-child")
if err != nil {
t.Fatalf("GetDependencyRecords error: %v", err)
}
if len(depRecords) != 1 {
t.Fatalf("expected 1 dependency record, got %d: %+v", len(depRecords), depRecords)
}
if depRecords[0].DependsOnID != "bd-source-parent" || depRecords[0].Type != types.DepParentChild {
t.Fatalf("dependency = %s -> %s (%s), want bd-source-child -> bd-source-parent (%s)",
depRecords[0].IssueID, depRecords[0].DependsOnID, depRecords[0].Type, types.DepParentChild)
}
}
func TestEnginePreviewDependenciesDedupesPendingRelations(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
issues := []*types.Issue{
{ID: "bd-preview-source", Title: "Source", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
{ID: "bd-preview-target", Title: "Target", Status: types.StatusOpen, IssueType: types.TypeTask, Priority: 2},
}
for i, issue := range issues {
if err := store.CreateIssue(ctx, issue, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
ref := fmt.Sprintf("https://test.test/EXT-PREVIEW-%d", i+1)
if err := store.UpdateIssue(ctx, issue.ID, map[string]interface{}{"external_ref": ref}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref: %v", err)
}
}
tracker := newMockTracker("test")
var messages []string
engine := NewEngine(tracker, store, "test-actor")
engine.OnMessage = func(msg string) { messages = append(messages, msg) }
errCount := engine.previewDependencies(ctx, []DependencyInfo{
{
FromExternalID: "EXT-PREVIEW-1",
ToExternalID: "EXT-PREVIEW-2",
Type: string(types.DepRelated),
Source: DependencySourceRelation,
},
{
FromExternalID: "EXT-PREVIEW-1",
ToExternalID: "EXT-PREVIEW-2",
Type: string(types.DepRelated),
Source: DependencySourceParent,
},
}, nil)
if errCount != 0 {
t.Fatalf("previewDependencies errCount = %d, want 0", errCount)
}
dependencyLines := 0
summaryFound := false
for _, msg := range messages {
if strings.Contains(msg, "Would create dependency:") {
dependencyLines++
}
if strings.Contains(msg, "Would create 1 dependencies") {
summaryFound = true
}
}
if dependencyLines != 1 || !summaryFound {
t.Fatalf("dry-run messages = %v, want one dependency preview and a one-dependency summary", messages)
}
}
func TestEnginePullHydratesNewPrelinkedExternalRefAfterLastSync(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
lastSync := time.Now().UTC().Add(-2 * time.Hour)
if err := store.SetLocalMetadata(ctx, "linear.last_sync", lastSync.Format(time.RFC3339)); err != nil {
t.Fatalf("SetLocalMetadata error: %v", err)
}
localRef := "https://linear.app/team/issue/TEAM-123/stub"
local := &types.Issue{
ID: "bd-prelinked-after-sync",
Title: "Local stub",
Description: "stub",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
ExternalRef: strPtr(localRef),
CreatedAt: lastSync.Add(30 * time.Minute),
UpdatedAt: lastSync.Add(30 * time.Minute),
}
if err := store.CreateIssue(ctx, local, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
base := newMockTracker("linear")
base.issues = []TrackerIssue{{
ID: "linear-internal-123",
Identifier: "TEAM-123",
URL: "https://linear.app/team/issue/TEAM-123/remote-title",
Title: "Remote title",
Description: "Remote description",
Priority: 1,
UpdatedAt: lastSync.Add(-30 * time.Minute),
}}
base.fetchIssues = func(_ context.Context, opts FetchOptions) ([]TrackerIssue, error) {
if opts.Since == nil {
return base.issues, nil
}
return nil, nil
}
lt := &mockExternalRefTracker{
mockTracker: base,
buildRef: func(issue *TrackerIssue) string {
return "https://linear.app/team/issue/" + issue.Identifier
},
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ""
}
return strings.Split(parts[1], "/")[0]
},
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
}
engine := NewEngine(lt, store, "test-actor")
engine.PushHooks = &PushHooks{ContentEqual: func(local *types.Issue, remote *TrackerIssue) bool {
return local.Title == remote.Title && local.Description == remote.Description
}}
result, err := engine.Sync(ctx, SyncOptions{Pull: true, Push: true})
if err != nil {
t.Fatalf("Sync error: %v", err)
}
if result.PullStats.Updated != 1 {
t.Fatalf("PullStats = %+v, want one hydrated update", result.PullStats)
}
if len(base.updated) != 0 {
t.Fatalf("pushed updates = %+v, want none after hydration", base.updated)
}
got, err := store.GetIssue(ctx, local.ID)
if err != nil {
t.Fatalf("GetIssue error: %v", err)
}
if got.Title != "Remote title" || got.Description != "Remote description" {
t.Fatalf("hydrated issue = %q/%q, want remote content", got.Title, got.Description)
}
if got.ExternalRef == nil || *got.ExternalRef != "https://linear.app/team/issue/TEAM-123" {
t.Fatalf("external_ref = %#v, want canonical prelinked ref", got.ExternalRef)
}
}
func TestEnginePullHydratesOlderIssueWhenExternalRefAddedAfterLastSync(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
local := &types.Issue{
ID: "bd-prelinked-existing",
Title: "Local stub",
Description: "stub",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
CreatedAt: time.Now().UTC().Add(-4 * time.Hour),
UpdatedAt: time.Now().UTC().Add(-4 * time.Hour),
}
if err := store.CreateIssue(ctx, local, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
lastSync := time.Now().UTC()
if err := store.SetLocalMetadata(ctx, "linear.last_sync", lastSync.Format(time.RFC3339Nano)); err != nil {
t.Fatalf("SetLocalMetadata error: %v", err)
}
time.Sleep(10 * time.Millisecond)
localRef := "https://linear.app/team/issue/TEAM-456/stub"
if err := store.UpdateIssue(ctx, local.ID, map[string]interface{}{"external_ref": localRef}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref error: %v", err)
}
base := newMockTracker("linear")
base.issues = []TrackerIssue{{
ID: "linear-internal-456",
Identifier: "TEAM-456",
URL: "https://linear.app/team/issue/TEAM-456/remote-title",
Title: "Remote title",
Description: "Remote description",
Priority: 1,
UpdatedAt: lastSync.Add(-30 * time.Minute),
}}
base.fetchIssues = func(_ context.Context, opts FetchOptions) ([]TrackerIssue, error) {
if opts.Since == nil {
return base.issues, nil
}
return nil, nil
}
lt := &mockExternalRefTracker{
mockTracker: base,
buildRef: func(issue *TrackerIssue) string {
return "https://linear.app/team/issue/" + issue.Identifier
},
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ""
}
return strings.Split(parts[1], "/")[0]
},
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
}
engine := NewEngine(lt, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true})
if err != nil {
t.Fatalf("Sync error: %v", err)
}
if result.PullStats.Updated != 1 {
t.Fatalf("PullStats = %+v, want one hydrated update", result.PullStats)
}
got, err := store.GetIssue(ctx, local.ID)
if err != nil {
t.Fatalf("GetIssue error: %v", err)
}
if got.Title != "Remote title" || got.Description != "Remote description" {
t.Fatalf("hydrated issue = %q/%q, want remote content", got.Title, got.Description)
}
if got.ExternalRef == nil || *got.ExternalRef != "https://linear.app/team/issue/TEAM-456" {
t.Fatalf("external_ref = %#v, want canonical prelinked ref", got.ExternalRef)
}
}
func TestEngineSyncPrelinkedHydrationFailureStopsPushAndLastSync(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
local := &types.Issue{
ID: "bd-prelinked-failure",
Title: "Local stub",
Description: "stub",
Status: types.StatusOpen,
IssueType: types.TypeTask,
Priority: 2,
CreatedAt: time.Now().UTC().Add(-4 * time.Hour),
UpdatedAt: time.Now().UTC().Add(-4 * time.Hour),
}
if err := store.CreateIssue(ctx, local, "test-actor"); err != nil {
t.Fatalf("CreateIssue error: %v", err)
}
lastSync := time.Now().UTC()
lastSyncStr := lastSync.Format(time.RFC3339Nano)
if err := store.SetLocalMetadata(ctx, "linear.last_sync", lastSyncStr); err != nil {
t.Fatalf("SetLocalMetadata error: %v", err)
}
time.Sleep(10 * time.Millisecond)
localRef := "https://linear.app/team/issue/TEAM-789/stub"
if err := store.UpdateIssue(ctx, local.ID, map[string]interface{}{"external_ref": localRef}, "test-actor"); err != nil {
t.Fatalf("UpdateIssue external_ref error: %v", err)
}
base := newMockTracker("linear")
base.fetchIssueErr = fmt.Errorf("linear fetch failed")
base.fetchIssues = func(_ context.Context, opts FetchOptions) ([]TrackerIssue, error) {
if opts.Since == nil {
return base.issues, nil
}
return nil, nil
}
lt := &mockExternalRefTracker{
mockTracker: base,
buildRef: func(issue *TrackerIssue) string {
return "https://linear.app/team/issue/" + issue.Identifier
},
extract: func(ref string) string {
parts := strings.Split(ref, "/issue/")
if len(parts) != 2 {
return ""
}
return strings.Split(parts[1], "/")[0]
},
isRef: func(ref string) bool {
return strings.Contains(ref, "linear.app/") && strings.Contains(ref, "/issue/")
},
}
engine := NewEngine(lt, store, "test-actor")
result, err := engine.Sync(ctx, SyncOptions{Pull: true, Push: true})
if err == nil {
t.Fatalf("Sync error = nil, want hydration failure")
}
if result == nil || result.Success {
t.Fatalf("result = %+v, want unsuccessful result", result)
}
if !strings.Contains(err.Error(), "hydrating pre-linked linear issues") {
t.Fatalf("Sync error = %v, want hydration context", err)
}
if len(base.created) != 0 || len(base.updated) != 0 {
t.Fatalf("push ran after hydration failure: created=%d updated=%d", len(base.created), len(base.updated))
}
gotLastSync, err := store.GetLocalMetadata(ctx, "linear.last_sync")
if err != nil {
t.Fatalf("GetLocalMetadata error: %v", err)
}
if gotLastSync != lastSyncStr {
t.Fatalf("last_sync = %q, want unchanged %q", gotLastSync, lastSyncStr)
}
}
func TestEngineCreateDependencies_UnresolvableRef(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
// Both external refs don't exist — should generate warnings
deps := []DependencyInfo{
{FromExternalID: "https://test.test/MISSING-1", ToExternalID: "https://test.test/MISSING-2", Type: string(types.DepBlocks)},
}
errCount := engine.createDependencies(ctx, deps)
if errCount == 0 {
t.Error("expected errCount > 0 for unresolvable external refs")
}
// Warnings should be collected
if len(engine.warnings) == 0 {
t.Error("expected warnings for unresolvable refs, got none")
}
found := false
for _, w := range engine.warnings {
if strings.Contains(w, "MISSING-1") || strings.Contains(w, "resolve") {
found = true
break
}
}
if !found {
t.Errorf("expected warning about unresolvable ref, got: %v", engine.warnings)
}
}
func TestEngineCreateDependencies_Empty(t *testing.T) {
ctx := context.Background()
store := newTestStore(t)
defer store.Close()
tracker := newMockTracker("test")
engine := NewEngine(tracker, store, "test-actor")
// Empty deps list should return 0
errCount := engine.createDependencies(ctx, nil)
if errCount != 0 {
t.Errorf("createDependencies(nil) returned %d, want 0", errCount)
}
errCount = engine.createDependencies(ctx, []DependencyInfo{})
if errCount != 0 {
t.Errorf("createDependencies([]) returned %d, want 0", errCount)
}
}
func TestEngineWarnCollectsMessages(t *testing.T) {
tracker := newMockTracker("test")
engine := &Engine{
Tracker: tracker,
Actor: "test-actor",
}
// Verify warn() collects messages
engine.warn("warning %d", 1)
engine.warn("warning %d", 2)
if len(engine.warnings) != 2 {
t.Fatalf("expected 2 warnings, got %d", len(engine.warnings))
}
if engine.warnings[0] != "warning 1" {
t.Errorf("warnings[0] = %q, want %q", engine.warnings[0], "warning 1")
}
if engine.warnings[1] != "warning 2" {
t.Errorf("warnings[1] = %q, want %q", engine.warnings[1], "warning 2")
}
// Verify OnWarning callback is also called
var callbackMsgs []string
engine.OnWarning = func(msg string) {
callbackMsgs = append(callbackMsgs, msg)
}
engine.warn("warning %d", 3)
if len(callbackMsgs) != 1 {
t.Fatalf("expected 1 callback message, got %d", len(callbackMsgs))
}
if callbackMsgs[0] != "warning 3" {
t.Errorf("callback got %q, want %q", callbackMsgs[0], "warning 3")
}
if len(engine.warnings) != 3 {
t.Errorf("expected 3 total warnings, got %d", len(engine.warnings))
}
}