Six internal/tracker TestEngine* tests have failed since they were
introduced (083181e1e, fix-merge of PR #2759): locally they self-skip
unless the pinned dolt-sql-server image is cached, and CI only compiles
the package. The Dolt 2.1.4 bump made the cached image match again,
which is what surfaced them. Three were real engine bugs, now fixed:
- Sync() clobbered batch-push warnings: result.Warnings = e.warnings
overwrote the BatchPushResult warnings appended a few lines earlier.
Merge instead.
- dependencyIssueResolver never extracted the tracker identifier from
the *queried* ref, so URL variants of the same issue (e.g. Linear
URLs with and without the title slug) failed to resolve.
- A bidirectional sync echoed freshly pulled content straight back to
the tracker: doPull now records created/updated IDs into skipPushIDs.
Plus a timestamp bug shown by the rerun tests: Dolt DATETIME rounds
sub-second values, so a pull's own write can land up to half a second
in the future of the last_sync recorded at sync end; the next pull
then misread the engine's own write as a local edit, skipped the
remote update, and advanced last_sync past it - permanently dropping
that remote change from incremental pulls. last_sync is now recorded
at the next whole second.
Test repairs: the mock tracker's BuildExternalRef now prefers
issue.URL like every real tracker (notion/linear/github), and two
stale tests seed last_sync via SetLocalMetadata, which is what the
engine reads, instead of SetConfig.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2799 lines
87 KiB
Go
2799 lines
87 KiB
Go
//go:build cgo
|
|
|
|
package tracker
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"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
|
|
}
|
|
|
|
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).
|
|
// The engine reads last_sync from local metadata, not config.
|
|
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)
|
|
}
|
|
|
|
// 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.SetLocalMetadata(ctx, "test.last_sync", lastSync.Format(time.RFC3339)); err != nil {
|
|
t.Fatalf("SetLocalMetadata() 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))
|
|
}
|
|
}
|