package beads_test import ( "context" "errors" "fmt" "testing" "github.com/steveyegge/beads" "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/storage/dolt" "github.com/steveyegge/beads/internal/storage/domain" "github.com/steveyegge/beads/internal/types" ) func TestReExportCommitIndeterminate(t *testing.T) { t.Parallel() if beads.ErrCommitIndeterminate != storage.ErrCommitIndeterminate { t.Error("beads.ErrCommitIndeterminate is not the shared storage sentinel value (identity broken)") } if dolt.ErrCommitIndeterminate != storage.ErrCommitIndeterminate { t.Error("dolt.ErrCommitIndeterminate is not the shared storage sentinel value (identity broken)") } wrapped := fmt.Errorf("update issue: %w", storage.ErrCommitIndeterminate) if !errors.Is(wrapped, beads.ErrCommitIndeterminate) { t.Errorf("errors.Is(wrapped, beads.ErrCommitIndeterminate) = false; err = %v", wrapped) } } // TestReExportCloseBlocked proves the public beads.ErrCloseBlocked alias is the // same value as the internal sentinel and composes through errors.Is when // wrapped — the property CloseIssueChecked callers rely on to detect a guard // refusal without importing internal/storage. func TestReExportCloseBlocked(t *testing.T) { t.Parallel() if beads.ErrCloseBlocked != storage.ErrCloseBlocked { t.Error("beads.ErrCloseBlocked is not the internal sentinel value (identity broken)") } wrapped := fmt.Errorf("x: %w", beads.ErrCloseBlocked) if !errors.Is(wrapped, beads.ErrCloseBlocked) { t.Errorf("errors.Is(wrapped, beads.ErrCloseBlocked) = false; err = %v", wrapped) } } // TestReExportVersionMismatch proves the public beads.ErrVersionMismatch alias // is the same value as the internal sentinel and composes through errors.Is when // wrapped — the property a CloseIssueChecked caller relies on to detect an // optimistic-concurrency refusal without importing internal/storage. func TestReExportVersionMismatch(t *testing.T) { t.Parallel() if beads.ErrVersionMismatch != storage.ErrVersionMismatch { t.Error("beads.ErrVersionMismatch is not the internal sentinel value (identity broken)") } wrapped := fmt.Errorf("x: %w", beads.ErrVersionMismatch) if !errors.Is(wrapped, beads.ErrVersionMismatch) { t.Errorf("errors.Is(wrapped, beads.ErrVersionMismatch) = false; err = %v", wrapped) } } // TestUpdateIssueOptionsIsExported proves the public beads.UpdateIssueOptions // alias is usable from outside the module and its ExpectedVersion compare-and- // swap field round-trips — the type a caller names to opt a // Storage.UpdateIssueChecked into optimistic concurrency without importing // internal/storage. The zero value must leave ExpectedVersion nil (no check). func TestUpdateIssueOptionsIsExported(t *testing.T) { t.Parallel() v := int64(7) opts := beads.UpdateIssueOptions{ExpectedVersion: &v} if opts.ExpectedVersion == nil || *opts.ExpectedVersion != 7 { t.Fatalf("ExpectedVersion did not round-trip through the exported alias: %+v", opts) } if (beads.UpdateIssueOptions{}).ExpectedVersion != nil { t.Fatal("zero-value UpdateIssueOptions must have a nil ExpectedVersion (no check)") } } // TestReExportedSentinelIdentity proves each public sentinel is the SAME value // as the internal one it aliases, so errors.Is composes across the package // boundary without any bridging. func TestReExportedSentinelIdentity(t *testing.T) { t.Parallel() cases := []struct { name string exported error internal error }{ {"ErrNotFound", beads.ErrNotFound, storage.ErrNotFound}, {"ErrAlreadyClaimed", beads.ErrAlreadyClaimed, storage.ErrAlreadyClaimed}, {"ErrNotClaimable", beads.ErrNotClaimable, storage.ErrNotClaimable}, {"ErrVersionMismatch", beads.ErrVersionMismatch, storage.ErrVersionMismatch}, {"ErrSelfDependency", beads.ErrSelfDependency, domain.ErrSelfDependency}, {"ErrDependencyCycle", beads.ErrDependencyCycle, domain.ErrDependencyCycle}, {"ErrDependencySourceNotFound", beads.ErrDependencySourceNotFound, domain.ErrDependencySourceNotFound}, {"ErrDependencyTargetNotFound", beads.ErrDependencyTargetNotFound, domain.ErrDependencyTargetNotFound}, {"ErrFieldTooLong", beads.ErrFieldTooLong, types.ErrFieldTooLong}, } for _, tc := range cases { if tc.exported != tc.internal { t.Errorf("beads.%s is not the internal sentinel value (identity broken)", tc.name) } } } // stubDepRepo satisfies domain.DependencySQLRepository via the embedded // interface; only the two methods dependencyUseCaseImpl.add consults before // returning a self-dep/cycle sentinel are implemented. Any other call would // nil-panic, which keeps the stub honest about the exact surface these // branches touch. type stubDepRepo struct { domain.DependencySQLRepository hasCycle bool } func (s stubDepRepo) ValidateBlockingHierarchy(context.Context, *types.Dependency) error { return nil } func (s stubDepRepo) HasCycle(context.Context, string, string) (bool, error) { return s.hasCycle, nil } // TestReExportedSentinelCatchesRealProductionError drives ACTUAL converted // production returns — the domain dependency use case's self-dep and cycle // branches — and asserts the PUBLIC aliases match them via errors.Is. This is // the property the re-export exists to provide, verified end to end through // real code rather than by wrapping a sentinel with itself. func TestReExportedSentinelCatchesRealProductionError(t *testing.T) { t.Parallel() uc := domain.NewDependencyUseCase(stubDepRepo{}) selfErr := uc.AddDependency(context.Background(), &types.Dependency{IssueID: "a", DependsOnID: "a", Type: types.DepBlocks}, "tester") if !errors.Is(selfErr, beads.ErrSelfDependency) { t.Errorf("errors.Is(real self-dep err, beads.ErrSelfDependency) = false; err = %v", selfErr) } uc = domain.NewDependencyUseCase(stubDepRepo{hasCycle: true}) cycleErr := uc.AddDependency(context.Background(), &types.Dependency{IssueID: "a", DependsOnID: "b", Type: types.DepBlocks}, "tester") if !errors.Is(cycleErr, beads.ErrDependencyCycle) { t.Errorf("errors.Is(real cycle err, beads.ErrDependencyCycle) = false; err = %v", cycleErr) } } // insertErrDepRepo returns preset errors from the two methods the domain // dependency use-case consults before its typed-conflict passthrough branches: // ValidateBlockingHierarchy (hierarchy conflict) and Insert (type conflict). Any // other call nil-panics through the embedded interface, keeping the stub honest // about the surface these branches touch. type insertErrDepRepo struct { domain.DependencySQLRepository hierarchyErr error insertErr error } func (r insertErrDepRepo) ValidateBlockingHierarchy(context.Context, *types.Dependency) error { return r.hierarchyErr } func (r insertErrDepRepo) HasCycle(context.Context, string, string) (bool, error) { return false, nil } func (r insertErrDepRepo) Insert(context.Context, *types.Dependency, string, domain.DepInsertOpts) error { return r.insertErr } // TestReExportedDependencyConflictTypes proves the public // beads.DependencyTypeConflictError and beads.DependencyHierarchyConflictError // aliases are the SAME struct types the engine returns: driving ACTUAL domain // use-case passthrough returns (the conflict is passed through unwrapped, the // property both write stacks now share), errors.As classifies each through the // public alias and reads its fields — no message parsing. func TestReExportedDependencyConflictTypes(t *testing.T) { t.Parallel() // Type conflict: a different-type edge already exists between the pair. typeConflict := &domain.DependencyTypeConflictError{ IssueID: "a", DependsOnID: "b", ExistingType: "blocks", RequestedType: "related", } uc := domain.NewDependencyUseCase(insertErrDepRepo{insertErr: typeConflict}) err := uc.AddDependency(context.Background(), &types.Dependency{IssueID: "a", DependsOnID: "b", Type: types.DepRelated}, "tester") var gotType *beads.DependencyTypeConflictError if !errors.As(err, &gotType) { t.Fatalf("errors.As(real type-conflict err, *beads.DependencyTypeConflictError) = false; err = %v", err) } if gotType.IssueID != "a" || gotType.DependsOnID != "b" || gotType.ExistingType != "blocks" || gotType.RequestedType != "related" { t.Errorf("extracted type-conflict fields = %+v, want {a b blocks related}", gotType) } // Hierarchy conflict: a blocking edge would gate an issue on its ancestor. hierConflict := &domain.DependencyHierarchyConflictError{ IssueID: "child", BlockerID: "ancestor", BlockerIsAncestor: true, } uc = domain.NewDependencyUseCase(insertErrDepRepo{hierarchyErr: hierConflict}) err = uc.AddDependency(context.Background(), &types.Dependency{IssueID: "child", DependsOnID: "ancestor", Type: types.DepBlocks}, "tester") var gotHier *beads.DependencyHierarchyConflictError if !errors.As(err, &gotHier) { t.Fatalf("errors.As(real hierarchy-conflict err, *beads.DependencyHierarchyConflictError) = false; err = %v", err) } if gotHier.IssueID != "child" || gotHier.BlockerID != "ancestor" || !gotHier.BlockerIsAncestor { t.Errorf("extracted hierarchy-conflict fields = %+v, want {child ancestor true}", gotHier) } // Endpoint miss: the target names no row this database holds. The domain // use case passes it through unwrapped for the same reason the two // conflicts above are passed through. missing := &domain.DependencyEndpointNotFoundError{ IssueID: "a", DependsOnID: "ghost", MissingID: "ghost", Err: domain.ErrDependencyTargetNotFound, } uc = domain.NewDependencyUseCase(insertErrDepRepo{insertErr: missing}) err = uc.AddDependency(context.Background(), &types.Dependency{IssueID: "a", DependsOnID: "ghost", Type: types.DepBlocks}, "tester") var gotMissing *beads.DependencyEndpointNotFoundError if !errors.As(err, &gotMissing) { t.Fatalf("errors.As(real endpoint-miss err, *beads.DependencyEndpointNotFoundError) = false; err = %v", err) } if !errors.Is(err, beads.ErrDependencyTargetNotFound) { t.Errorf("errors.Is(real endpoint-miss err, beads.ErrDependencyTargetNotFound) = false; err = %v", err) } if gotMissing.IssueID != "a" || gotMissing.DependsOnID != "ghost" || gotMissing.MissingID != "ghost" { t.Errorf("extracted endpoint-miss fields = %+v, want {a ghost ghost}", gotMissing) } } // TestReExportFieldTooLong proves the public beads.ErrFieldTooLong alias is the // same value as the internal types sentinel and composes through errors.Is when // wrapped — the property length-validation callers rely on to detect an // over-length assignee/owner/label without importing internal/types. It also // checks the MaxFieldLen constant re-export tracks the source of truth. func TestReExportFieldTooLong(t *testing.T) { t.Parallel() if beads.ErrFieldTooLong != types.ErrFieldTooLong { t.Error("beads.ErrFieldTooLong is not the internal sentinel value (identity broken)") } wrapped := fmt.Errorf("x: %w", beads.ErrFieldTooLong) if !errors.Is(wrapped, beads.ErrFieldTooLong) { t.Errorf("errors.Is(wrapped, beads.ErrFieldTooLong) = false; err = %v", wrapped) } if beads.MaxFieldLen != types.MaxFieldLen { t.Errorf("beads.MaxFieldLen = %d, want types.MaxFieldLen = %d", beads.MaxFieldLen, types.MaxFieldLen) } }