Compare commits

..

1 commit

Author SHA1 Message Date
Eddie the Engineer
4319e4820d fix(configfile): resolve an absent proxy idle timeout on sidecar load (bd-mnhq6)
#6673 made SaveProxiedServerClientInfo persist the effective idle timeout,
but only on write. Sidecars written by every release so far omit
idle_timeout when it was defaulted, and nothing rewrites them, so
LoadProxiedServerClientInfo still handed back the zero sentinel. For any
pre-upgrade workspace `bd dolt status` dropped the field even though the
proxy reaps at the 30s default, and "default" stayed indistinguishable
from "unset".

Add configfile.EffectiveProxyIdleTimeout (0 -> DefaultProxyIdleTimeout;
every other value, including the negative "never" sentinel, unchanged)
and resolve the value on Load as well as Save.

Migration resume compares the loaded sidecar with the plan recorded in
its journal, and journals from v1.3.0-rc.2 through v1.3.2-rc.2 record a
defaulted timeout as 0. With a Load-only change, a migration interrupted
before an upgrade would refuse to resume in both directions ("migration
sidecar does not match prepared state"). Compare effective timeouts in
migrationSidecarsEquivalent, and resolve the forward plan in place at
target_configured as Save already does on the uninterrupted path. A
timeout that really changed is still refused.

Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 17:29:01 +00:00
543 changed files with 2333 additions and 63118 deletions

View file

@ -201,8 +201,7 @@ document what the pinned release does, never main-only features. See
## 9. Verify before you call it done
Run the gates in [references/verification.md](references/verification.md).
The short list: `bazel test //test/docsync:docsync_test --config=ci`
(nav↔file sync + link conventions),
The short list: `go test ./test/docsync` (nav↔file sync + link conventions),
`./scripts/generate-cli-docs.sh --check` (generated docs fresh),
`./scripts/check-doc-freshness.sh` (Last reviewed markers), and a live
preview with `make docs-dev` (or `./mint.sh dev`) at `localhost:3000`.

View file

@ -39,9 +39,8 @@ don't measure that work by the word delta.
*not* simplifying — it buries the real change in the diff.
4. **Loss-check** (below).
5. **Fact-check** (below).
6. **Gates:** `bazel test //test/docsync:docsync_test --config=ci`, every
fence parses, no body H1, no HTML comments (MDX), preview with
`make docs-dev`.
6. **Gates:** `go test ./test/docsync`, every fence parses, no body H1, no
HTML comments (MDX), preview with `make docs-dev`.
7. **Preview, then commit on approval** — one page or section per batch, so
the reviewer can steer before a cut compounds across the section.

View file

@ -8,7 +8,7 @@ Run these before considering docs work complete. Ordered cheapest-first.
# 1. Docs sync: docs.json nav <-> file consistency, link conventions
# (root-relative extensionless in docs/, exact paths in engdocs/ and
# curated root files), orphan detection (only CLI_REFERENCE.md is exempt).
bazel test //test/docsync:docsync_test --config=ci
go test ./test/docsync
# 2. Generated CLI docs freshness: regenerates from the live command tree
# and diffs docs/CLI_REFERENCE.md, docs/cli-reference/, and the CLI

View file

@ -11,7 +11,7 @@
# t.Parallel) add up, parallel ones share -test.parallel=4.
# Regenerate with scripts/ci/gen_embedded_cmd_shard_manifest.py 100
# --weights=duration --write after adding, splitting or removing
# TestEmbedded* functions in cmd/bd/*_test.go. --write is
# TestEmbedded* functions in cmd/bd/*_embedded_test.go. --write is
# incremental: it keeps every already-assigned test on its current shard
# and only places newly-discovered names, onto whichever shard is
# currently lightest, so two unrelated PRs that each add one test do not
@ -59,206 +59,105 @@
100 17 TestEmbeddedReopen
100 18 TestEmbeddedLabelPropagateRename
100 18 TestEmbeddedPrune_protectsBeadCitedByCustomStatusBead
100 19 TestEmbeddedLabelConcurrent
100 19 TestEmbeddedNewDoltStore_StrictReadOnlyRefusesWritesOnFreshDatabase
100 20 TestEmbeddedInitRoleRoutingRetainedFork
100 20 TestEmbeddedMigrateSchema_IdentityMismatchRefusesBeforeApplying
100 21 TestEmbeddedMaxRowsReady
100 21 TestEmbeddedMigratePersonal_movesIssues
100 22 TestEmbeddedCount
100 22 TestEmbeddedIfRevisionCloseReplaysMoleculeAutoClose
100 23 TestEmbeddedCountConcurrent
100 23 TestEmbeddedExportExcludeOwner_flag
100 24 TestEmbeddedEventsTailFollowReportsTruncationOnTheStream
100 24 TestEmbeddedUndeferConcurrent
100 24 TestEmbeddedWispGCProtectsActiveWisps
100 25 TestEmbeddedDoltRemoteAdd_LocalOnly_FiresBeforeGuard
100 25 TestEmbeddedMaxRowsListBasic
100 25 TestEmbeddedRemovedBackendHealRejectionPerBackend
100 26 TestEmbeddedDoltRemoteAdd_JSON_AllowGitOrigin_WarningOnStderr
100 26 TestEmbeddedExternalMutationPolicy
100 26 TestEmbeddedPersistentPreRunLogsAndSkipsIdentityCheckForFreshEmbeddedWorkspace
100 27 TestEmbeddedDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy
100 27 TestEmbeddedNewDoltStoreFromConfig_DottedDBName
100 27 TestEmbeddedShipConcurrent
100 28 TestEmbeddedDoltLocalOnly_RemoteAdd_RefusesExitOne
100 28 TestEmbeddedHistoryConcurrent
100 28 TestEmbeddedImportChunkedRealStoreResumeConverges
100 29 TestEmbeddedDoltLocalOnly_RemoteAdd_ErrorOnStderr
100 29 TestEmbeddedEpicCloseEligibleReasonFlag
100 29 TestEmbeddedImportChunkedNoReadyWindowWithReadinessEdgeIntoCycle
100 30 TestEmbeddedCloseGuardsAndEpics
100 30 TestEmbeddedDoltLocalOnly_Push_ExitsZeroWithMessage
100 30 TestEmbeddedImportChunkedCrossBucketBlocksEdgesResumeBackfills
100 31 TestEmbeddedDoltLocalOnly_ConfigRoundTrip
100 31 TestEmbeddedIfRevisionCloseWarnsOnForcedOpenChildren
100 31 TestEmbeddedInitSelectedExcludeRoutingForkInvalidQuiet
100 32 TestEmbeddedDoctorUnsupportedJSON
100 32 TestEmbeddedIfRevisionAdvertisedOnFourVerbs
100 32 TestEmbeddedListSearchAndOutputFormats
100 33 TestEmbeddedBootstrapJSONLAndGitOrigin
100 33 TestEmbeddedDeleteJournalsTheRequestingActor
100 33 TestEmbeddedExportExcludeOwner_verbose
100 34 TestEmbeddedCopyIssueRelations_preservesCommentWithTimestamp
100 34 TestEmbeddedEventsTailReportsTruncationToTheCLI
100 34 TestEmbeddedUnclaimBatchAndRefusals
100 34 TestEmbeddedWispGCPurgeClosedDoesNotCascadeIntoLiveSteps
100 35 TestEmbeddedAutoPruneRespectsBdConfigSet
100 35 TestEmbeddedEventsReadNoticesADisabledJournal
100 35 TestEmbeddedGateCreateBeadRename
100 35 TestEmbeddedVersionedHistoryEnvIsProcessWideAndOnlyTurnsRecordingOn
100 36 TestEmbeddedAutoPruneLeavesAnUnboundedJournalAlone
100 36 TestEmbeddedDoltRemoteResetData_UnknownRemote
100 36 TestEmbeddedGateConcurrent
100 36 TestEmbeddedUnclaimIfAssigneeCLIDifferentSpelling
100 37 TestEmbeddedAutoPruneBoundsTheJournalAfterAMutatingCommand
100 37 TestEmbeddedDoltRemoteResetData_CloudRemoteRefused
100 37 TestEmbeddedMaxRowsDepTreeAndDuplicates
100 37 TestEmbeddedSpawnMolecule_SubstitutesTemplatedStepFields
100 38 TestEmbeddedGraphConcurrent
100 38 TestEmbeddedRoutedCreateJournalsIntoTheTargetWorkspace
100 38 TestEmbeddedUnclaimIfAssigneeFlagValidation
100 39 TestEmbeddedIfRevisionRejectsLabelAndParentEdits
100 39 TestEmbeddedMaxRowsGraph
100 39 TestEmbeddedNewDoltStoreFromConfig_NoMetadata
100 40 TestEmbeddedIfRevisionOutranksReassignFenceCLI
100 40 TestEmbeddedNewDoltStoreFromConfig_HyphenatedDBName
100 40 TestEmbeddedUpdateLifecycleClaimParentCommit
100 41 TestEmbeddedDuplicateConcurrent
100 41 TestEmbeddedVersionedHistoryFollowsTheStoreItWritesInto
100 42 TestEmbeddedInitAForkAutoContributor
100 42 TestEmbeddedUpdateIfGuardsFlagValidation
100 43 TestEmbeddedIfRevisionMultiIDRejected
100 43 TestEmbeddedInitExplicitBeadsDirIsAuthoritative
100 44 TestEmbeddedIfRevisionComposesWithIfAssigneeIfStatus
100 44 TestEmbeddedStaleConcurrent
100 45 TestEmbeddedGraph
100 45 TestEmbeddedUpdateIfGuardsCLI
100 46 TestEmbeddedCloseAlreadyClosedClaimNextAndMolecule
100 46 TestEmbeddedIfRevisionMatchAndMismatch
100 47 TestEmbeddedListSearchAndOutputSearchAndSort
100 47 TestEmbeddedRevisionRemintMatrix
100 48 TestEmbeddedDeferConcurrent
100 48 TestEmbeddedReassignFenceCLI
100 49 TestEmbeddedBackupRestoreStrictReadonly
100 49 TestEmbeddedInitAPushConsentAndRemoteBootstrap
100 49 TestEmbeddedMigratePersonal_abortOnNoConfirm
100 50 TestEmbeddedDiffConcurrent
100 50 TestEmbeddedDoltRemoteAdd_AllowGitOrigin_WarningOnStderr
100 50 TestEmbeddedImportChunkedWaitsForChildImportedLaterStaysBlocked
100 50 TestEmbeddedVersionOutputShape
100 51 TestEmbeddedDoltRemoteAdd_AllowGitOrigin_Exits0
100 51 TestEmbeddedHistoryAndShowAsOfReadDoltCommits
100 51 TestEmbeddedImportChunkedStaleRejectedRowKeepsDeferredDepsOut
100 51 TestEmbeddedInitGitBootstrapRoutingFreshQuiet
100 52 TestEmbeddedConfigSetOtherKeysSkipTheVersionedHistoryScan
100 52 TestEmbeddedDoltLocalOnly_Push_LocalStoreCopy
100 52 TestEmbeddedImportChunkedNoReadyWindowAtAnyFreezePoint
100 52 TestEmbeddedSwarmConcurrent
100 53 TestEmbeddedDoltLocalOnly_Push_JSON_DisabledStatus
100 53 TestEmbeddedIfRevisionOrdinaryCAS
100 53 TestEmbeddedImportChunkedMixedRegularWispCrossBucketEdgesWired
100 53 TestEmbeddedInitSelectedExcludeRoutingStealthDecoyQuiet
100 54 TestEmbeddedDiscoveryPinsEnvFileReadonly
100 54 TestEmbeddedFormatJSONAliasMatchesJSON
100 54 TestEmbeddedGraphModeDependencyWorkspaceUnaffected
100 54 TestEmbeddedInitAgentArtifactsGolden
100 54 TestEmbeddedSearchConcurrent
100 54 TestEmbeddedShowAsOfFailureExitCodes
100 55 TestEmbeddedDoltLocalOnly_Pull_JSON_DisabledStatus
100 55 TestEmbeddedImportChunkedConcurrentUpdateKeepsDeferredDeps
100 55 TestEmbeddedUndefer
100 55 TestEmbeddedVersionedHistorySwitchScansEveryRowNotOnePage
100 56 TestEmbeddedDepNoCycleCheck
100 56 TestEmbeddedDoltLocalOnly_Pull_ExitsZeroWithMessage
100 56 TestEmbeddedImportChunkedConcurrentUpdateKeepsBlockingDeps
100 56 TestEmbeddedVersionedHistorySwitchRoundTrip
100 57 TestEmbeddedDoltLocalOnly_DoltStatus_ShowsDisabled
100 57 TestEmbeddedIfRevisionDeletePreflightGoneIsPreconditionFailed
100 57 TestEmbeddedQueryConcurrent
100 57 TestEmbeddedVersionedHistorySwitchRefusesUnversionableMetadata
100 58 TestEmbeddedDepAAddRejectionsAndBulk
100 58 TestEmbeddedDoctorUnsupportedProse
100 58 TestEmbeddedIfRevisionCascadeDelete
100 58 TestEmbeddedVersionedHistorySwitchRefusesAnUnrecordableGateTimeout
100 59 TestEmbeddedDeferAutoWake
100 59 TestEmbeddedDoctorSupportedChecks
100 59 TestEmbeddedIdentityGateRendersSchemaSkewFromForwardDriftedWorkspace
100 59 TestEmbeddedVersionedHistorySetManyRefusesUnversionableMetadata
100 60 TestEmbeddedCommentsCLI
100 60 TestEmbeddedCorruptMetadataFailsLoudUntilRestored
100 60 TestEmbeddedExportExcludeOwner_config
100 60 TestEmbeddedRoutedWriteMissDoesNotCreateTargetDatabase
100 60 TestEmbeddedWispGCPurgeClosedStillPurgesFullyClosedMolecules
100 61 TestEmbeddedBootstrapCloneFailureScrubsCredentials
100 61 TestEmbeddedContributorRoutedWritesCommitInPlanning
100 61 TestEmbeddedEventsPruneHonorsRetainRowsFloorFromConfig
100 61 TestEmbeddedUpdateRoutedStoreCommitsTargetHead
100 61 TestEmbeddedVersionedHistoryConfigSetWritesTheStoreRow
100 62 TestEmbeddedAutoPruneDoesNotRunForReadOnlyCommands
100 62 TestEmbeddedDoltRemoteResetData_GitBacked
100 62 TestEmbeddedGateCheckSkipsTemplateGates
100 62 TestEmbeddedReadyBlockersAndLabels
100 62 TestEmbeddedUnclaimIfAssigneeCLI
100 63 TestEmbeddedDepAndLinkBatchAutoCommitDoesNotAdvanceHead
100 63 TestEmbeddedGateCheckLimitCountsOnlyLiveGates
100 63 TestEmbeddedIfRevisionDeletePreflightGoneParentIsPreconditionFailed
100 63 TestEmbeddedListPageEdges
100 64 TestEmbeddedAutoExportExcludeOwner_config
100 64 TestEmbeddedDoltRemoteAdd_NoGitOrigin_ProceedsNormally
100 64 TestEmbeddedGateWaiterCheckLifecycle
100 64 TestEmbeddedPromoteMovesAWispParent
100 64 TestEmbeddedSpawnMolecule_PreservesStepLabels
100 65 TestEmbeddedIfRevisionPreflightGoneIsPreconditionFailedOnEveryVerb
100 65 TestEmbeddedRemovedBackendHealRoundTrip
100 65 TestEmbeddedSupersede
100 66 TestEmbeddedCloseBasicIsolatedStores
@ -323,7 +222,6 @@
100 71 TestEmbeddedCloseJSONReportsMoleculeAutoClose
100 71 TestEmbeddedInitRoleRoutingExplicitDefault
100 71 TestEmbeddedPrimeChangeDirRedirectNoticeFollowsTarget
100 71 TestEmbeddedRoutedCreateHonorsTheEnvOverrideOverTheTargetsConfig
100 71 TestEmbeddedSearchRoutesAgree
100 72 TestEmbeddedContributorCreateMultiple
@ -434,10 +332,8 @@
100 83 TestEmbeddedPurgeFiltered
100 83 TestEmbeddedReadyConcurrent
100 84 TestEmbeddedDoltRemoteAdd_GitOriginCollision_Exits1
100 84 TestEmbeddedInitGitBootstrapRoutingDecoyInvalid
100 84 TestEmbeddedInitSelectedExcludeRoutingStealthInvalid
100 84 TestEmbeddedMigratePersonal_preservesComments
100 85 TestEmbeddedBootstrapExistingDryRunInit
100 85 TestEmbeddedChildrenBasicAndEmpty
@ -446,10 +342,8 @@
100 85 TestEmbeddedIfRevisionReopenGuardDirect
100 85 TestEmbeddedInitArtifactRouting
100 86 TestEmbeddedDoltRemoteAdd_DifferentURL_ProceedsNormally
100 86 TestEmbeddedExplicitHierarchicalParentEdges
100 86 TestEmbeddedInitHooksRouting
100 86 TestEmbeddedMigratePersonal_noopWhenEmpty
100 87 TestEmbeddedCreateRepoProxiedTargetError
100 87 TestEmbeddedGateInheritsDownParentChain

View file

@ -176,17 +176,14 @@
40 3 TestTransactionCleanupBeforeSQLCommitRemainsDefinite
40 3 TestUnknownProvenanceLeaseStaysReclaimable
40 4 TestBlockedListerContract
40 4 TestCreateBatchFastPathsMatchPerRowSmallDepAdd_Embedded
40 4 TestEmbeddedIssueOperationsUpdateLabelPatchOrdering
40 4 TestEmbeddedReaderGetMissIsNotFoundAndBackendFailureDoesNotDecay
40 4 TestEmbeddedReaderListFilterFamiliesNarrowToTheirRows
40 4 TestMergeAndSettleWithStrategy_EmptyStrategyMatchesMergeAndSettle
40 5 TestEmbeddedClaimerRefusesIncompleteRequestsAndAnAbsentIDWithoutTouchingState
40 5 TestEmbeddedIssueOperationsCloseAndReopenAWisp
40 5 TestEmbeddedReaderListKeysetPositionResumesTheCreatedDescIDAscOrder
40 5 TestRecordVersionKeepsSubSecondChangeAt
40 5 TestWithPeerAuth
40 6 TestCreateBatchFastPathsMatchPerRowApplyWaitsFor_Embedded
@ -196,7 +193,6 @@
40 6 TestEmbeddedRelationsAnswersAWispTargetInTheOutDirection
40 6 TestPromoteStillWorksWithCollisionGuard
40 6 TestSearchWithMissingWispPlaneTables
40 6 TestVersionedHistoryKeepsNumbersTheStoreDistinguishesApart
40 7 TestConcurrencyMultiProcess
40 7 TestEmbeddedBatchCloserRecordsOneHistoryEntryForWhatLanded
@ -205,20 +201,17 @@
40 7 TestEmbeddedIssueOperationsUpdateMetadataReplaceClearsAndValidates
40 7 TestEmbeddedLenientOpenWarning_DataBehind
40 7 TestEmbeddedRelationsLeavesTheCallersRequestAlone
40 7 TestLoseVersionLeavesTheEpochTablesCommitted
40 7 TestMergeAndSettleWithStrategy_ResolvesDeclinedConflict
40 8 TestDeleterContract
40 8 TestEmbeddedDependencyEditorRoutesWispSourcedRemovalToTheWispPlane
40 8 TestEmbeddedMergeAndSettleDirtyWorkingSetSurvivesRefusedMerge
40 8 TestEmbeddedMintLeavesUpdatedAtWhereHistoryOffDoes
40 8 TestEmbeddedReaderGetBriefDepsProjectsTheDependencyRows
40 8 TestEmbeddedRelationsOrdersNeighborsFromBothPlanesTogether
40 8 TestEmbeddedReopenIssueCategorySemantics
40 8 TestGetIssueCommentsPageEmbedded
40 8 TestListWisps
40 9 TestBumpEpochCarryingNeitherCarriesNorServesARowFromAFutureEpoch
40 9 TestEmbeddedDependencyEditorRefusesCrossPlaneCycle
40 9 TestEmbeddedDependencyEditorSameTypeReAddIsIdempotent
40 9 TestEmbeddedDependencyEditorSnapshotsTheRequest
@ -237,10 +230,8 @@
40 10 TestGraphCounterContract
40 10 TestIgnoredCursorHealRespectsOperatorOverride
40 10 TestRunInTransactionPostCommitStageFailureIsIndeterminate
40 10 TestVersionedHistoryOffMatchesPreStackGolden_Embedded
40 10 TestWithPeerAuth_WarnsWhenStoredPeerSuppressesAmbientPasswordAmbient
40 11 TestABumpUnderOneStoreIDMovesTheEpochSeenThroughEveryStoreID
40 11 TestEmbeddedBatchCreateFirstVersionCarriesCreationTimeEdges
40 11 TestEmbeddedClaimerRefusalMessagesCarryTheirFragments
40 11 TestEmbeddedGuardedUpdateMintsOnceAfterItsPatches
@ -260,7 +251,6 @@
40 12 TestEmbeddedReadyClaimerAnswersTheQuestionReaderReadyLists
40 12 TestHistoryPresenceContract
40 12 TestLifecycleUpdateContract
40 12 TestReaderListExcludeStatusAcceptsAWorkspaceCustomStatus
40 13 TestEmbeddedDepRekeyConvergesRenameChain
40 13 TestEmbeddedDependencyEditorAppliesParentChildBeforeBlockingEdges
@ -281,7 +271,6 @@
40 14 TestEmbeddedReaderReadyDefaultTypeExclusionsYieldToAnExplicitType
40 14 TestEmbeddedReadyClaimerClaimsTheFrontRowAndReturnsThePostClaimState
40 14 TestEmbeddedReadyClaimerDoesNotMutateTheCallerRequest
40 14 TestHeartbeatIssueCommitsARefusalOnlyWhenItReadTheIssueEmbedded
40 14 TestHistory_NullTextColumns
40 15 TestCreateIssuesRejectStaleUpserts
@ -318,7 +307,6 @@
40 17 TestStatsReporterContract
40 17 TestVersionReconcilerContract
40 18 TestCreateBatchParticipationGeneration
40 18 TestEmbeddedBatchCloserIdempotentRecloseIsAPerItemSuccess
40 18 TestEmbeddedDependencyEditorMixedBatchWritesBothPlanes
40 18 TestEmbeddedIssueOperationsUpdateRawMetadataTakesTheFunnelsValueShapes
@ -338,11 +326,9 @@
40 19 TestIgnoredCursorHealConvergesFromEveryCrashState
40 19 TestOpenAfterCloseCreatesNewStore
40 19 TestOpenReturnsCachedStore
40 19 TestParticipationGenerationFixtureKitIsWired
40 19 TestRemoteVerbsPresentStoredPeerCredentials
40 19 TestRenameLabelMintsOneVersionPerTouchedBead
40 20 TestBumpEpochCarryingCarriesOnlyTheLineageHoldingTheNewestRow
40 20 TestCreateIssue
40 20 TestEmbeddedCheckedWrappersRouteTheirPreconditions
40 20 TestEmbeddedIssueOperationsCreateRoutesInfraTypesToWisps
@ -354,7 +340,6 @@
40 20 TestHeartbeatRejectsWispEmbedded
40 20 TestIgnoredCursorHealNeverResurrectsRolledBackVersions
40 21 TestBumpEpochCarryingCarriesTheLiveRowsOfEveryStoreInTheDatabase
40 21 TestCreateRejectsCrossTableIDCollision
40 21 TestEmbeddedBatchCloserItemsAnswerToTheCloseGuards
40 21 TestEmbeddedDependencyEditorAcceptsATypeOutsideTheConstants
@ -378,7 +363,6 @@
40 22 TestLeaseLifecycleEmbedded
40 22 TestPolicyBlockingAnnotatorForeignOpensAreSublinear
40 23 TestAsOfReadContract
40 23 TestEmbeddedBatchCloserBackendFailureReturnsNoOutcomes
40 23 TestEmbeddedBatchCloserClaimNextHydratesWhenSomethingClosed
40 23 TestEmbeddedDependencyEditorAcceptsBlockingAcrossIssueTypes
@ -404,14 +388,12 @@
40 24 TestReopenIssue
40 25 TestBatchGetterContract
40 25 TestDatabases
40 25 TestDualWriteFixtureKitIsWired
40 25 TestEmbeddedBatchCloserClaimNextIsNilWhenNothingClosed
40 25 TestEmbeddedIssueOperationsUpdateClaimHonorsConfiguredActiveStatuses
40 25 TestEmbeddedReadyClaimerLeavesEphemeralRowsOutOfTheDefaultReadySet
40 25 TestEmbeddedReadyClaimerRejectsLimitOffsetBriefAndEmptyActor
40 25 TestGetDependentRecordsForIssuesEmbedded
40 25 TestHeartbeaterContract
40 25 TestIgnoredCursorHealIsIdempotent
40 25 TestIsBlockedBatchEmbedded
40 25 TestReadyWorkPageTotal
@ -441,7 +423,6 @@
40 27 TestRemoteGitDataRefOnEngine
40 27 TestSweeperContract
40 28 TestBumpEpochCarryingDoesNotCarryALostLineage
40 28 TestEmbeddedBatchCloserForceBypassesOnlyClosePolicy
40 28 TestEmbeddedBatchCloserSettlesTheDependersOfWhatItClosed
40 28 TestEmbeddedClaimerClaimsAnUnassignedOpenIssueAndAnswersTheBareRow
@ -460,7 +441,6 @@
40 29 TestEmbeddedDependencyEditorRecordsOneHistoryEntryPerLandedRequest
40 29 TestEmbeddedMergeAndSettleMetadataConflict
40 29 TestEmbeddedReaderListDefaultExclusionsAndTheirOverrides
40 29 TestEmbeddedReaderListTimeBoundsAreStrictAndWholeSecond
40 29 TestEmbeddedReaderReadySetOwnsItsStatusPinnedAndTemplateDecisions
40 29 TestEmbeddedTransactionSameStatusDoesNotPublishUnrelatedDurableChanges
40 29 TestEventsJournalAccessor
@ -479,7 +459,6 @@
40 30 TestLegacyTrackedIgnoredCursorUnwedgesPull
40 30 TestUpdateMergeOps_DoltEngine_TwoIssues
40 31 TestBumpEpochCarryingWritesOneCarryRowPerLiveIDNamingTheLineageRoot
40 31 TestDualWriteContract
40 31 TestEmbeddedDependencyEditorAcceptsAForeignRepoTarget
40 31 TestEmbeddedDependencyEditorMaintainsBlockedStateAcrossPlanes
@ -492,7 +471,6 @@
40 31 TestReadyCounterContract
40 31 TestWithPeerAuth_KeyMismatchFailsClosed
40 32 TestCurrentAddressForNeverReseedsAnAbsentStoreEpochRow
40 32 TestEmbeddedClaimerGrantsALiveLeaseOnTheRowItWonAndLeavesARefusedOneAlone
40 32 TestEmbeddedDependencyEditorRefusesAMissingLocalTarget
40 32 TestEmbeddedDirtyTablesGate_BlocksReopenThenWorkingSetReconcileRecovers
@ -513,13 +491,11 @@
40 33 TestEmbeddedRelationsResolvesTheAnchorIDExactly
40 33 TestEmbeddedSyncCommitsConfigBeforeMerge
40 33 TestEventsAutoPruneThrottleSkipsTheSecondPass
40 33 TestFirstMintLeavesTheEpochTablesCommitted
40 33 TestGetDependentRecordsEmbedded
40 33 TestPruneEventsBatchDeletesTheLowestSeqsOnly
40 33 TestTreeWalkerContract
40 34 TestAddLabel
40 34 TestBumpEpochCarryingLeavesTheEpochTablesCommitted
40 34 TestDecryptPassword_KeyMismatchNamesTheLocalKey
40 34 TestEmbeddedBlockedRecheckRecordsUnblockingWrites
40 34 TestEmbeddedDependencyEditorAttributesItsEventsToTheActor
@ -543,7 +519,6 @@
40 35 TestReadyWorkWithMissingDeferredParentTables
40 35 TestReclaimExpiredLeaseSurvivesRestartEmbedded
40 36 TestBumpEpochCarryingFailsAndRollsBackWhenARowAlreadyExistsAtTheNewEpoch
40 36 TestCommenterContract
40 36 TestConcurrentOpenReturnsCached
40 36 TestEmbeddedBatchCloserAllRefusedBatchRecordsNoHistory
@ -566,7 +541,6 @@
40 37 TestEmbeddedMergeAndSettleReportsOperatorConflicts
40 37 TestEmbeddedReaderListBriefDropsTheFreeFormTextAndNothingElse
40 37 TestEmbeddedReaderListNaturalNumericIDSortTrimsAfterTheFetch
40 37 TestEpochWritesReportAnUnpublishedCommitAsIndeterminate
40 37 TestIgnoredCursorHealRespectsOverrideUnderBroaderPattern
40 38 TestCreateIssues
@ -590,7 +564,6 @@
40 39 TestEmbeddedMigrateRepairedDependenciesIDColumnCommitsAtomicallyWithVersion53_4690
40 39 TestEmbeddedReaderListSkipCountsDropsTheCardinalitiesAndNothingElse
40 39 TestEmbeddedRelationsResolvesAWispAnchor
40 39 TestParticipationGenerationFence
40 39 TestPreviewStoreRefusesLocalMetadataWrite
40 39 TestReclaimRefusesForeignReplicaLease
40 39 TestWorkspaceConfigContract

View file

@ -3,7 +3,7 @@
#
# Usage: embedded-test-shard.sh <shard_number> <total_shards>
#
# Discovers all TestEmbedded* top-level functions in cmd/bd/*_test.go.
# Discovers all TestEmbedded* top-level functions from cmd/bd/*_embedded_test.go.
# Tests listed in embedded-cmd-test-shards.txt for the requested shard count use
# that committed assignment; newly-added tests fall back to hash(name) % total.
# Runs the matching subset using the pre-built test binary at
@ -33,12 +33,8 @@ fi
SHARD_INDEX=$(( SHARD_NUMBER - 1 ))
MANIFEST="${BEADS_TEST_SHARD_MANIFEST:-.github/scripts/embedded-cmd-test-shards.txt}"
# Discover all top-level TestEmbedded* functions across every cmd/bd test
# file, by name rather than by file glob (as proxied-test-shard.sh does): a
# test gated on BEADS_TEST_EMBEDDED_DOLT runs in this lane or in none, wherever
# it lives. scripts/embedded_lane_coverage_test.go fails on a gated test this
# selection misses.
ALL_TESTS=$(grep -rh '^func TestEmbedded' cmd/bd/*_test.go \
# Discover all top-level TestEmbedded* functions.
ALL_TESTS=$(grep -rh '^func TestEmbedded' cmd/bd/*_embedded_test.go \
| sed 's/func \(TestEmbedded[A-Za-z0-9_]*\).*/\1/' \
| sort -u)

View file

@ -69,7 +69,6 @@
34 6 TestProxiedServerServeReadsTheJournalItJustWrote
34 6 TestProxiedServerSwarm
34 6 TestProxiedServerUpdate2B
34 6 TestProxiedServerVersionedHistorySwitchRefusesAnUnrecordableGateTimeout
34 6 TestProxiedServerWispList
34 7 TestProxiedServerCloseConcurrent
@ -157,7 +156,6 @@
34 17 TestProxiedServerPrime
34 17 TestProxiedServerSQLDatabaseFlag
34 17 TestProxiedServerServeModeGate
34 17 TestServerModeServeIgnoresGraphModeDependency
34 18 TestProxiedServerClose3
34 18 TestProxiedServerCount
@ -256,13 +254,11 @@
34 30 TestProxiedServerStatus
34 30 TestProxiedServerTodo
34 30 TestProxiedServerUpdate2
34 30 TestProxiedServerVersionedHistoryServeActivatesTheProviderFromItsOwnRow
34 31 TestProxiedServerCloseBeadGate
34 31 TestProxiedServerComment
34 31 TestProxiedServerConfigB
34 31 TestProxiedServerEventsJournal
34 31 TestProxiedServerGateAddWaiterConvoy
34 31 TestProxiedServerIfRevisionGuardClose
34 31 TestProxiedServerMolBond

View file

@ -1085,7 +1085,7 @@ jobs:
outputs:
result: ${{ steps.result.outputs.result }}
env:
PURE_CMD_BD_TESTS: '^Test(Help|CheckRemoteSafety|FormatDestroyToken|ShouldWireInitRemote|ExtractPrefix|IsNumericID|GetWorktreeGitDir|DriftItemStatuses|RunDriftChecks|IsServerProbablyRunning|CheckHooksDriftNotGitRepo|CheckServerDriftNoBeadsDir|CheckRemoteDriftNoBeadsDir|NocgoFactoriesHonorSharedServer|NocgoNewDoltStoreFromConfig_ErrorSuggestsCorrectFlag|NocgoNewReadOnlyStoreFromConfig_ErrorSuggestsCorrectFlag|NocgoStoreFactoriesRefuseGraphWorkspace)'
PURE_CMD_BD_TESTS: '^Test(Help|CheckRemoteSafety|FormatDestroyToken|ShouldWireInitRemote|ExtractPrefix|IsNumericID|GetWorktreeGitDir|DriftItemStatuses|RunDriftChecks|IsServerProbablyRunning|CheckHooksDriftNotGitRepo|CheckServerDriftNoBeadsDir|CheckRemoteDriftNoBeadsDir|NocgoFactoriesHonorSharedServer|NocgoNewDoltStoreFromConfig_ErrorSuggestsCorrectFlag|NocgoNewReadOnlyStoreFromConfig_ErrorSuggestsCorrectFlag)'
# The only pre-merge run of these boundaries: where it executes
# remotely --config=sole-run fails on a remote cache eviction instead
# of re-running the whole invocation (whose retry could turn a failed

View file

@ -126,29 +126,9 @@ make install # build and install bd to ~/.local/bin (canonical)
certificate `--config=remote-exec`, agent hosts whose `~/.bazelrc` names the
executor neither. Make yours the default with a `build --config=...` line in
the gitignored `.bazelrc.local`, or pass `BAZEL_FLAGS=...` to make.
- Agents run tests only with `bazel test`, also while iterating on one
behavior:
```bash
bazel test //cmd/bd:bd_test --config=ci --test_filter='^TestName$' --test_output=all
```
A target also passes when the test never ran (a filter that matches
nothing, a skip, a file the configuration does not compile), so count a run
only when its log shows `--- PASS: TestName` and no `--- SKIP` for the test
or a `TestName/...` subtest: Go prints `--- PASS` for a test whose every
subtest skipped. "Check That the Test Ran" in
[engdocs/TESTING.md](engdocs/TESTING.md) names the tests `--config=ci` does
not run (Dolt-backed, `-short`-gated, integration-tagged, `TestEmbedded*`
and embedded-Dolt, files `BUILD.bazel` does not list) and the way into
each. An unchanged target returns its cached result, which is the same
evidence. Finish with `make test`.
- Agents do not run `go test` (`./scripts/test.sh`, `make test-go`): CI does
not enforce it, it skips nogo, gofmt and the guards, and agent hosts may
refuse it. It stays a convenience for humans working offline. The exception
is regenerating golden files (`make corpus-regen`, `make githooks-regen`,
`BD_UPDATE_GOLDEN=1`), which Bazel cannot do: see "Regenerating Golden
Files" in [engdocs/TESTING.md](engdocs/TESTING.md).
- `go test` (`./scripts/test.sh`, `make test-go`) is an inner-loop
convenience only. CI does not enforce it, and it skips nogo, gofmt and the
guards; finish with `make test`.
- **Do NOT** use `go build -o bd ./cmd/bd`, `go install ./cmd/bd`, or raw
`go run ./cmd/bd ...`: they bypass the canonical build path, leave stale
binaries, and raw `go run` misses the `gms_pure_go` tag. Use `make install`,

View file

@ -74,13 +74,6 @@ exports_files(
visibility = ["//scripts:__pkg__"],
)
# //scripts:shell_scripts_test: Oracle A's runner, whose EXIT-trap removal of
# its reference worktree oracle_a_script_test.go checks in a fixture repository.
exports_files(
["tests/oracle-a/run-oracle-a.sh"],
visibility = ["//scripts:__pkg__"],
)
# The nested Go modules' go.mod files, which mark where the root module ends:
# //scripts:go_test_sources_test's scan of every _test.go file skips their
# trees, as `go test ./...` does. (go.mod is in no Go partition below: it is
@ -253,20 +246,6 @@ exports_files(
visibility = ["//internal/httpclient/encode:__pkg__"],
)
# --- begin go_srcs (managed by tools/bazel/go_srcs.py; run `make bazel-sync`) ---
filegroup(
name = "go_srcs",
srcs = glob(
["**/*.go"],
allow_empty = True,
exclude = ["bazel-*/**"],
),
visibility = ["//:__subpackages__"],
)
# --- end go_srcs ---
# --- begin repo_files (managed by tools/bazel/go_srcs.py; run `make bazel-sync`) ---
filegroup(
@ -365,7 +344,6 @@ filegroup(
"//internal/httpclient/encode:repo_doc_files",
"//internal/httpclient/wire:repo_doc_files",
"//internal/idgen:repo_doc_files",
"//internal/initprocs:repo_doc_files",
"//internal/jira:repo_doc_files",
"//internal/linear:repo_doc_files",
"//internal/lockfile:repo_doc_files",
@ -405,7 +383,6 @@ filegroup(
"//internal/storage/externaldeps:repo_doc_files",
"//internal/storage/fs:repo_doc_files",
"//internal/storage/git:repo_doc_files",
"//internal/storage/historyoffequiv:repo_doc_files",
"//internal/storage/issueops:repo_doc_files",
"//internal/storage/journalscan:repo_doc_files",
"//internal/storage/kvkeys:repo_doc_files",
@ -436,7 +413,6 @@ filegroup(
"//internal/utils:repo_doc_files",
"//internal/validation:repo_doc_files",
"//internal/versioncheck:repo_doc_files",
"//internal/versionedhistory:repo_doc_files",
"//internal/workapi:repo_doc_files",
"//internal/workapi/storecounter:repo_doc_files",
"//internal/workapi/storequerier:repo_doc_files",
@ -602,7 +578,6 @@ filegroup(
"//internal/httpclient/encode:repo_go_srcs",
"//internal/httpclient/wire:repo_go_srcs",
"//internal/idgen:repo_go_srcs",
"//internal/initprocs:repo_go_srcs",
"//internal/jira:repo_go_srcs",
"//internal/linear:repo_go_srcs",
"//internal/lockfile:repo_go_srcs",
@ -642,7 +617,6 @@ filegroup(
"//internal/storage/externaldeps:repo_go_srcs",
"//internal/storage/fs:repo_go_srcs",
"//internal/storage/git:repo_go_srcs",
"//internal/storage/historyoffequiv:repo_go_srcs",
"//internal/storage/issueops:repo_go_srcs",
"//internal/storage/journalscan:repo_go_srcs",
"//internal/storage/kvkeys:repo_go_srcs",
@ -673,7 +647,6 @@ filegroup(
"//internal/utils:repo_go_srcs",
"//internal/validation:repo_go_srcs",
"//internal/versioncheck:repo_go_srcs",
"//internal/versionedhistory:repo_go_srcs",
"//internal/workapi:repo_go_srcs",
"//internal/workapi/storecounter:repo_go_srcs",
"//internal/workapi/storequerier:repo_go_srcs",
@ -824,7 +797,6 @@ filegroup(
"//internal/httpclient/encode:repo_go_test_srcs",
"//internal/httpclient/wire:repo_go_test_srcs",
"//internal/idgen:repo_go_test_srcs",
"//internal/initprocs:repo_go_test_srcs",
"//internal/jira:repo_go_test_srcs",
"//internal/linear:repo_go_test_srcs",
"//internal/lockfile:repo_go_test_srcs",
@ -864,7 +836,6 @@ filegroup(
"//internal/storage/externaldeps:repo_go_test_srcs",
"//internal/storage/fs:repo_go_test_srcs",
"//internal/storage/git:repo_go_test_srcs",
"//internal/storage/historyoffequiv:repo_go_test_srcs",
"//internal/storage/issueops:repo_go_test_srcs",
"//internal/storage/journalscan:repo_go_test_srcs",
"//internal/storage/kvkeys:repo_go_test_srcs",
@ -895,7 +866,6 @@ filegroup(
"//internal/utils:repo_go_test_srcs",
"//internal/validation:repo_go_test_srcs",
"//internal/versioncheck:repo_go_test_srcs",
"//internal/versionedhistory:repo_go_test_srcs",
"//internal/workapi:repo_go_test_srcs",
"//internal/workapi/storecounter:repo_go_test_srcs",
"//internal/workapi/storequerier:repo_go_test_srcs",
@ -1055,7 +1025,6 @@ filegroup(
"//internal/httpclient/encode:repo_other_files",
"//internal/httpclient/wire:repo_other_files",
"//internal/idgen:repo_other_files",
"//internal/initprocs:repo_other_files",
"//internal/jira:repo_other_files",
"//internal/linear:repo_other_files",
"//internal/lockfile:repo_other_files",
@ -1095,7 +1064,6 @@ filegroup(
"//internal/storage/externaldeps:repo_other_files",
"//internal/storage/fs:repo_other_files",
"//internal/storage/git:repo_other_files",
"//internal/storage/historyoffequiv:repo_other_files",
"//internal/storage/issueops:repo_other_files",
"//internal/storage/journalscan:repo_other_files",
"//internal/storage/kvkeys:repo_other_files",
@ -1126,7 +1094,6 @@ filegroup(
"//internal/utils:repo_other_files",
"//internal/validation:repo_other_files",
"//internal/versioncheck:repo_other_files",
"//internal/versionedhistory:repo_other_files",
"//internal/workapi:repo_other_files",
"//internal/workapi/storecounter:repo_other_files",
"//internal/workapi/storequerier:repo_other_files",

View file

@ -9,128 +9,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Added
- `bd versions <id>` lists the versions recorded for a bead, and
`versioned-history.enabled` turns recording on. While it is on, every
accepted change to a bead created while it is on, or that enters the issues
plane while it is on (a wisp promoted or made persistent), stores a
snapshot of it as a row of `issue_versions` in the same transaction. It is
off by default and nothing is backfilled: a bead already on the issues
plane when it is turned on is legacy, and editing it records nothing. A
recorded write leaves `updated_at` where an unrecorded one would, so
`bd import`'s stale check sees the same timestamps either way.
`bd versions --json` answers `{"versions": [...], "recording": bool}`; the
command still lists what was recorded after recording is turned off, and
proxied-server and HTTP workspaces refuse it. The setting is a row of each
store's `config` table (`bd config set versioned-history.enabled true`),
and every store reads its own when it is opened: a write routed into
another workspace (a prefix-routed `bd update` or `bd close`,
`bd create --repo`) follows the target store's row, a proxied-server
provider reads it when it is constructed, and a long-lived `bd serve`
keeps the value it read until it restarts.
`BD_VERSIONED_HISTORY_ENABLED=1` (or a `config.yaml` value) turns
recording on for every store the process opens, and never turns it off.
The row replicates on `bd dolt push`/`pull`, and recording is single-writer
only: two clones recording at once can mint the same revision and fail the
pull, and a write from a writer that is not recording is folded into the
next recorded version under that version's actor, so keep recording on for
every writer of a store or off for all of them. Turning it on with
`bd config set` first checks every issue the store would version and
refuses, writing nothing, while any holds a number outside the I-JSON
exact-integer range (magnitude above 2^53-1, however it is spelled) in its
metadata or in a gate's timeout (held as nanoseconds, so about 104.25
days), and prints the count, the ids, the field and the fix. There is no
override, and the check runs once; after that, a recorded write that would
hold such a number fails atomically. Migration 0071 adds a nullable
`removed_restriction` column to `issue_versions`. `bd version` now refuses
an argument and suggests `bd versions <arg>`, instead of printing bd's
build for a mistyped `bd version bd-123`.
- `bd blocked --flags` prints the blocked flag for each id read from stdin
(one per line; blank lines and repeats ignored), with `--json` as
`[{"id","is_blocked"}]` in the order the ids were given, omitting an id that
names no row on either plane. A closed id is answered too, with its stored
flag (a `status <> 'closed'` SQL read of the column leaves it out). It is the flag `bd ready` filters on, not the
listing: a row whose stored flag is set with no nameable blocker reads true
here and is absent from `bd blocked`. It runs `issueops.BlockedFlags` on
every route; over HTTP that is `listBlockingAnnotations` with `is_blocked`,
behind `dependencies.blocking.isBlocked`, refused before the dial against a
server that does not advertise it. The listing's filter flags are refused
with `--flags`.
- `bd blocked --flags --raw` answers the stored `is_blocked` column itself,
without the external-dependency policy: a row blocked only by an
unsatisfied `external:` ref reads `false` (the policy-aware `--flags`
reads `true`); a stale flag reads `true` either way. `--raw` is for the
local and proxied routes, where it reads the column directly and the two
answer the same. Over HTTP it is answered only by a server that does not
advertise `policy.external_dependencies` (whose flag is the column); a
server advertising it answers only the policy-aware flag, so `--raw`
against it is refused before the dial rather than answered with the
decorated flag. `--raw` without `--flags` is refused.
- `bd blocked` works over a connected HTTP workspace. The blocked listing is
a role, `issueops.BlockedLister` (`ListBlocked(BlockedRequest{ParentID,
Labels, LabelsAny, ExcludeLabels}) -> BlockedResult{Items}`), on every
backend leg over the same body `GetBlockedIssues` runs, and `bd serve`
publishes it as `GET /v0/beads/blocked` (`parent`, and the repeatable
`label`, `label_any` and `exclude_label`), answering `{items, has_more}`
with `BlockedIssue` rows (the element `bd blocked --json` prints), behind
the new `blocked.list` capability token (additive; no wire_revision bump).
The listing names unsatisfied `external:` blockers wherever the
external-dependency policy applies: on the server when it advertises
`policy.external_dependencies`, else on the client, as every other policy
read does. The HTTP backend's `BlockedLister()` and legacy
`GetBlockedIssues` dial it; against a server that does not advertise the
token they refuse before dialing with a typed capability error naming
`blocked.list`, and never compose the listing from other reads. The
listing is unpaged: a server answer that reports `has_more` is refused
with the new `httpclient.TruncatedListingError` rather than returned
short, and an answer over the client's 32 MiB response limit is refused
as any oversized response is. The external-dependency decorator's legacy
`GetBlockedIssues` over an HTTP store now reads the extra sources through
the served roles (it failed on a raw multi-id read before), so callers of
that door no longer fail on it; commands that also make other raw reads
the HTTP backend does not serve (`bd ready --explain`) still refuse on
those. `bd
blocked` runs the role on every route (the proxied-server route through
the provider's accessor) with unchanged output: `--json` prints the same
rows in the same order (priority, then newest first, then id, which now
also breaks a tie the order used to leave to chance), and `[]`, never
`null`, when nothing is blocked.
- `bd list`'s remaining filters work over a connected HTTP workspace.
`GET /v0/beads/issues` accepts `updated_after`/`updated_before`,
`closed_after`/`closed_before`, `defer_after`/`defer_before`,
`due_after`/`due_before`, `priority`, `priority_min`, `priority_max`,
`title_contains`, `desc_contains`, `notes_contains`, `external_contains`,
`external_ref`, `spec`, `label_pattern`, `label_regex`,
`empty_description`, `no_labels`, `no_parent`, a repeatable
`exclude_type`, `pinned`, `no_pinned`, `deferred`, `overdue`, `mol_type`
and `wisp_type`, behind one new capability token, `issues.list.filters`
(additive; no wire_revision bump; the names are `issues:count`'s where it
already spells the filter), and applies them through the same Reader role a
local `bd list` reads through. Bounds are strict and compared at
whole-second precision on both routes; relative and date-only values are
resolved on the client's clock and timezone as locally, while `--overdue`
compares against the server's clock. Against a server that does not
advertise the token the client refuses before dialing, naming
`issues.list.filters`, rather than sending a filter an older server rejects
or dropping one and answering a wider listing. The 29 corresponding
divergence-ledger refusal rows are removed. The default `bd list --parent`
tree view does not carry these filters yet: its descendant walk still
refuses one over HTTP rather than drop it, and `--flat` or `--json` skips
the walk and applies them to the parent's direct children (not its whole
subtree).
- `issueops.ListRequest.ExcludeStatus`: statuses to leave out of a listing,
appended to the default exclusions (never re-admitting what they hide),
comma-separated or repeated, each validated against the workspace's
statuses like `CountRequest.ExcludeStatus` (an unknown name is
`ErrValidation`). `GET /v0/beads/issues` accepts it as a repeatable
`exclude_status` under the same `issues.list.filters` token (an unknown
name is a `400` on `exclude_status`), so an HTTP-backed caller can leave
closed history out of an `all` listing (`all` plus
`exclude_status=closed` keeps every status not named, the `pinned` and
`hooked` statuses and custom done/frozen statuses included) instead of
reading the whole history. It is refused together with `ReadyFlag`, like the other
members the ready query cannot carry. There is no `bd list` flag for it
yet.
- `bd serve` publishes the gate members: `await_type`,
`await_id`, `timeout` (nanoseconds) and `waiters` on `POST
/v0/beads/issues` and on `issues:batchApply` create items, behind the new
@ -154,44 +32,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
capability error naming the missing token (never sent without the
member); a batchApply plan is checked whole, so no partial plan is sent.
A request naming no gate member is unaffected by either token.
- `bd heartbeat` works over a connected HTTP workspace.
The lease refresh is a role, `issueops.Heartbeater`
(`Heartbeat(HeartbeatRequest{Actor, IssueID}) -> HeartbeatResult{IssueID,
Holder, HeartbeatAt, LeaseExpiresAt, Rearmed}`), on every backend leg, and
`bd serve` publishes it as `POST /v0/beads/issues/{id}:heartbeat` behind the
new `issues.heartbeat` capability token (additive; no wire_revision bump),
with the new `lease_not_held` (409) problem code (`reason: ephemeral` for a
wisp). A refresh writes ONLY the lease row: the issue's `revision` is not
reminted (a guarded write against the pre-heartbeat token still lands), no
version, event, journal entry or Dolt commit is recorded, and no hook
fires. `Rearmed` is true only when the heartbeat created the caller's lease
row (a hand-doled claim's first heartbeat). A re-arm is recorded as a
mutation; a refresh is not: the re-arm remints `revision`, stamps
`updated_at`, records a `lease_rearmed` event, a journal entry and a
version, makes a Dolt commit and fires `on_update` (see Fixed); the
reported times are whole seconds, exactly what the lease row stores. The
HTTP backend's `Heartbeater()` and legacy `HeartbeatIssue` dial it;
against a server that does not advertise the token they refuse before
dialing with a typed capability error naming `issues.heartbeat`, and never
fall back to a re-claim or a metadata stamp. A
busy (503) answer is replayed, because a repeat only moves the expiry later.
`bd heartbeat` now runs the role on every route (the proxied-server route
through the provider's accessor), with the same
`{"id","status":"heartbeat","owner"}` success output and the same exit
codes. Refusal TEXT on stderr changes per route: the direct routes (Dolt
server, embedded) gain a `lease not held: ` prefix
(`heartbeat X: lease not held: issue not claimable: X status closed`); the
proxied-server route loses its
`Heartbeat: db: IssueSQLRepository.HeartbeatIssue: ` prefix and reads as the
direct routes do; over HTTP the refusal is the problem's detail, which names
the state found (`it is closed`, `an ephemeral wisp`, `open and not
claimed`) or, for a foreign holder, the native `issue already claimed by
<holder>`. An id that names no row answers not-found from the role rather
than "not claimable" (the CLI resolves the id first, so its output is
unchanged), and every refusal for a caller that holds no live claim
(closed, released, reclaimed, moved off in_progress, or a wisp) is
`issueops.ErrLeaseNotHeld`, which still matches `ErrNotClaimable`.
- `GET /v0/beads/dependencies/blocking` accepts `is_blocked`, behind the new
`dependencies.blocking.isBlocked` capability token (additive; no
wire_revision bump), and answers each item's stored, transitive
@ -499,70 +339,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Changed
- Over an HTTP workspace, `bd ready --json` without `BD_JSON_ENVELOPE` no
longer sends `GET /v0/beads/ready:count` after a page the limit cut short:
the total only went into the stderr hint. It lists one row past the limit
instead, and the hint says more issues matched without saying how many
(the wording the proxied-server route already uses). A local store, and the
envelope's `pagination.total`, keep the total.
- `bd` initializes its packages with `GOMAXPROCS` capped at 4 and hands it
back before `main` runs anything, so the garbage collections package
initialization triggers do not stop the world across every CPU of a large
host. On a 192-CPU machine this takes about 17 ms off every bd process. An
explicit `GOMAXPROCS` is restored as set.
- Over an HTTP workspace, `bd ready` no longer fetches `GET /v0/beads/context`
before its listing in every process only to learn whether the server
enforces the external-dependency policy. The answer is kept for 5 minutes
per server URL and pinned project under the user cache directory
(`BEADS_HTTP_POLICY_CACHE_TTL`, a duration, a number of seconds, or `off`),
and a handshake the process already holds still wins. Claims and closes
always ask the server.
- `bd serve` normalizes every RFC 3339 time bound on the issue listing and
count (`created_*`, `updated_*`, `closed_*`, and the new `defer_*` and
`due_*`) to UTC before it reaches storage. A bound carrying an offset
(`...+02:00`) now selects exactly what its `Z` twin does; previously a
backend whose timestamp column has no zone could read the offset bound's
wall clock and compare it hours off. `bd`'s own client always sent `Z`, so
its answers are unchanged.
- `bd serve` answers a `label_regex` the database cannot compile with
`400 invalid_argument` (`invalid_value` on `label_regex`) on
`GET /v0/beads/issues`, `GET /v0/beads/ready`, `GET /v0/beads/ready:count`
and `POST /v0/beads/issues:claimNext`, instead of `500 internal`. The pattern is
still compiled by the database in its own dialect; only the attribution
of its refusal changed.
- `issueops.Reader.List` refuses `PinnedFlag` together with `NoPinnedFlag`
with `ErrValidation` (`--pinned and --no-pinned are mutually exclusive`) on
every backend; it used to let `PinnedFlag` win silently. `bd list` already
refused the pair at flag parse, so its behavior is unchanged; over HTTP the
pair is a `400 invalid_argument` on `no_pinned`.
- `issueops.Reader.List` refuses `ParentID` together with `NoParent` with
`ErrValidation` (`--parent and --no-parent are mutually exclusive`) on
every backend, as `CountRequest` already did; it used to answer with only
the edge-less rows under the parent's dotted id, which both clauses match.
`bd list` already refused the pair at flag parse, so its behavior is
unchanged; over HTTP the pair is a `400 invalid_argument` on `no_parent`.
- **`bd gate discover` skips template gates, as `bd gate check` does.** A
template gh:run gate is a proto that work is poured from; on the direct,
proxied and embedded routes `bd gate discover` used to record a discovered
run ID on it, which every later pour copied. It is now left alone on every
route. `bd gate add-waiter` on a template gate is refused by the update
role's template guard, where the direct, proxied and embedded routes all
used to write the waiter.
- **`bd gate create` refuses a negative `--timeout` on every route**
(`timeout cannot be negative`); the direct, proxied and embedded routes
used to store it. A `--type` longer than 32 characters fails with the same
typed validation error instead of a raw Dolt column error.
- **`bd gate create` and `bd gate add-waiter` follow `dolt.auto-commit`
like every other role write.** Under `dolt.auto-commit=off` `bd gate
create` no longer makes its own Dolt commit on the direct and embedded
routes (the proxied route already did not). The Dolt commit messages are
the role's: `bd: create gate X blocking Y` becomes the create's default
message, and `bd gate add-waiter`'s becomes the update's (`bd: update X`
on the direct and embedded routes, `update issue` on the proxied route).
On the proxied route `bd gate create` no longer journals a
`dependency_added` event on the blocked issue, matching the direct route
and `bd create --deps`.
- **Gate members are bounds-checked in the library, on every local backend.**
`issueops.Lifecycle.Create`, `Lifecycle.Update` and `BatchApplier` (create
and update items) now refuse, with a typed `*issueops.GateFieldError`
@ -781,322 +557,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Fixed
- An HTTP workspace whose server cannot be reached now says which step
failed. A connect that is refused names the address and says nothing is
listening; one that times out (a filtered port, a down host) names the
address that never answered and how long it waited; a host name that does
not resolve is named as such. The error was the transport's
`Get "https://…/v0/beads/context": dial tcp …: i/o timeout`, which named the
request rather than the address.
- **`bd link` works over a connected HTTP workspace.** It wrote through the
store's raw `AddDependencyWithOptions`, which the HTTP client refuses, so
every `bd link` failed there with `operation "AddDependencyWithOptions" not
supported by the http backend`, whatever the type. It now writes through
the `DependencyEditor` role, the route `bd dep add` takes, on the direct
and HTTP routes alike (the proxied-server route is unchanged). Over HTTP
that is one `dependencies:add` request, so `bd link` keeps accepting any
non-empty type of at most 32 characters (`owned-by`, `ships-in`, ...).
An empty or over-long type is still refused before anything is written,
and an edge that already exists with another type still reports the typed
conflict. On a Dolt store the history commit is now the role's, like
`bd dep add`'s: `bd: dep add <from> <to>` in place of
`dependency: add <type> <from> -> <to>`.
- **`bd query` reports an uppercase duration unit as an unparseable time, not
a negated internal error.** `created>30M` failed with
`not a compact duration: "-30M"`, naming a value nobody typed; it now fails
with `cannot parse time expression: "30M"`. A signed spelling
(`created>+30M`) stops at the parser, as `created>+30x` already did, so
quote one to match it as a literal (`label="+30M"`). Units remain lowercase
(`30min`, `6h`, `7d`, `2w`, `3m`, `1y`); help and docs already say so.
- **Strict `--readonly` no longer creates workspace gate files.** A
`bd --readonly` command took its shared workspace gates with
create-if-missing, so on a workspace no bd command had gated yet it left
`<project>/.beads.gate.lock` and the physical-root gate file
(`.beads/embeddeddolt.gate.lock` or `.beads/dolt.gate.lock`) behind, although
strict readonly promises not to mutate the workspace. It now opens an
existing gate file read-only and holds it shared as before, so a maintenance
operation still sees it and a running one still makes it wait; when no gate
file exists it holds nothing. Every other command still creates the files.
- **Strict `--readonly` refuses `bd backup init`, `backup sync`,
`backup remove`, `backup restore` and `bd import`.** None of them checked
readonly mode. On a server-mode store they ran to completion under
`--readonly`: `backup init` and `backup remove` rewrote or emptied the
server's backup registry, `backup sync` wrote the backup destination,
`backup restore --force` replaced the store, and `import` wrote issues. On
an embedded store they failed with the storage layer's `store is read-only`
error instead, after `backup sync` had left `.beads/backup.lock` behind and
`backup restore` had left workspace-gate holder files. They now exit 1 with
the standard `Error: operation '<op>' is not allowed in read-only mode`,
and a restore is refused before it takes the exclusive workspace gate.
`bd import --dry-run` is refused too, as `bd create --dry-run` already is
and as a migration freeze already refuses it. `bd backup status` still runs
under `--readonly`.
- **`bd init --server --external` no longer starts a Dolt server of its own.**
Init builds its store config by hand and turned auto-start on for every
server init, so an `--external` init that named no port launched a
repo-local `dolt sql-server`, although `--external` says the server is
managed outside bd. `--external` now turns auto-start off. When the
external server cannot be reached, init gives one message on every route
(host and port, socket, shared server, auto-start pinned off): it names the
endpoint it dialed, says that bd did not start a server, and no longer
advises `bd dolt start`. With no port named at all, it asks for one
(`--server-port` or `BEADS_DOLT_SERVER_PORT`) instead of offering a default.
- **A failed `bd init --server` can be retried.** A first attempt that could
not reach its server left an empty `.beads/dolt` and nothing on disk that
records the server choice, so the legacy-upgrade guard refused every retry
as a "legacy Dolt workspace" and no bd command could repair it. When init
itself selects server mode, the guard now admits exactly that root: empty,
with no `.local_version` witness. A pre-1.0 witness, or a `.beads/dolt` that
holds anything, is still refused, and commands other than `bd init` are
decided as before.
- **A graph-mode workspace is refused instead of opened as an Issue store.**
Graph-preview builds mark their workspaces with `"graph_mode": "link"` and
`graph_*` binding fields in `metadata.json`, beside an ordinary Dolt
backend. bd opened such a workspace as an Issue store and ran Issue schema
initialization against the graph database, and every `metadata.json` rewrite
(including the `config.json` to `metadata.json` migration) dropped the
marker and the binding. Now any `graph_mode` other than `dependency`,
including a value bd does not recognize, makes every command that runs in
the workspace or names it with `--db` or `BEADS_DB` (`bd init`, `bd doctor`
and `bd bootstrap` included), and `bd create --repo` aimed at it, refuse it
before touching anything. The refusal names the format and exits with code
16, so installed beads git hooks refuse commits and pushes there too.
Commands that reach such a workspace only through a route from another
one, such as a routed `bd show`, fail without touching it, but not with
code 16. Store-less commands such as `bd version` and `bd help` still run.
A `metadata.json` rewrite keeps `graph_mode` and the `graph_*` fields
graph-preview builds write, and like those builds it omits a zero
`graph_schema_version` and a false `graph_ready`.
- **A graph workspace without `graph_mode` in its metadata is refused too.**
Graph-preview builds write a `.beads/graph-preview-format` marker before
`metadata.json`. bd ignored it. When an older bd had rewritten
`metadata.json` without `graph_mode`, bd opened the graph database by its
recorded name and ran Issue schema initialization against it; when
`metadata.json` was never written or was lost, bd fell back to the default
database name and created an Issue database inside the graph workspace, and
`bd init` initialized an Issue workspace there. A `.beads` holding that
marker, whatever it contains and whatever its metadata says (absent,
stripped, unparseable or an explicit `dependency`), is now refused wherever
a `graph_mode` workspace is: commands run in it or naming it with `--db` or
`BEADS_DB`, `bd create --repo` aimed at it, and `bd bootstrap` in a
workspace below it that would take its metadata exit with code 16 and a
hint to restore `metadata.json`, and routed and cross-repository opens fail
without opening its database.
- **The Go library's opens refuse a graph workspace too.**
`beads.OpenBestAvailable`, `OpenBestAvailableWith`, `OpenFromConfig` and
`OpenGated` opened a workspace whose `metadata.json` declares a
`graph_mode` other than `dependency`, or whose `.beads` holds the
`graph-preview-format` marker, as an Issue store and ran Issue schema
migrations into the graph database. They now
return `*beads.UnsupportedWorkspaceFormatError` (match it with `errors.As`)
before opening, creating or changing anything, the same refusal the CLI
exits 16 with.
- **`bd setup claude --remove` no longer leaves a blank-line hole.** Removing
the beads section from `CLAUDE.md` (or, with the other setup recipes, from
`AGENTS.md` or `GEMINI.md`) left the blank lines around it behind, three in
the `CLAUDE.md` `bd init` writes, and setup then re-added the section after
two more, so every remove and re-add grew the file. `--remove` now takes
those blank lines with the section, and setup appends a section after one
blank line, so removing and re-adding it toggles between the same two files.
A re-added section goes at the end of the file.
- **`bd config set` no longer truncates a `config.yaml` that has a line of
64 KiB or more.** Setting an undotted key (such as `actor` or `no-db`)
rewrites the file line by line, and a line of 65,536 bytes or more ended
that read early without an error, so the command reported success and wrote
back only the lines before the long one, plus the key it set. Dotted keys
and `bd config unset` were not affected. Setting an undotted key in such a
file now fails with `bufio.Scanner: token too long`. `bd config set` leaves
the file as it was. `set-many` stops at that key, but it has already written
any `config.yaml` keys listed before it, such as a dotted `sync.remote`.
- **`bd show --as-of` exits 1 when it reads no issue.** A ref the Dolt AS OF
read does not take (an instant, a versioned-history address), a ref that
does not exist, or an issue that did not exist at the ref was reported on
stderr while the command exited 0 with nothing on stdout, even under
`--json`. It now ends the way plain `bd show` does: exit 1, with the JSON
error envelope on stdout under `--json`. A batch that reads at least one of
its ids still exits 0. Both the direct and the proxied-server routes
changed.
- **`bd list --format dot` prints the same graph the same way every time.**
Nodes are declared in id order and edges in source, target and type order.
They used to follow the listing order, which breaks a priority tie by
creation time to the second, so two equal-priority issues swapped places
depending on whether they were created in the same second, and the
proxied-server route did not pin the order of one issue's edges. `--sort`
and `--limit` still choose which issues are listed.
- **`bd init --quiet` no longer prints "Removed SessionStart hook" or "Removed
PreCompact hook"** when the project's `.claude/settings.json` (or the legacy
`.claude/settings.local.json`) still carries the bare `bd prime` hooks an
older bd registered. The hooks are still migrated to the SessionStart
`bd prime --hook-json` hook; the removal lines now go to the installer's own
output, which `--quiet` discards, instead of straight to stdout.
- **A new `AGENTS.md` from `bd init` lists `bd dolt push` in its Quick
Reference only when the workspace has a Dolt remote.** The managed Beads
section already left out its push lines when no Dolt remote is configured or
the workspace is `no-push`, but the Quick Reference above it still showed
`bd dolt push # Push beads data to remote`. It now follows the same rule.
`bd init` still leaves an existing `AGENTS.md` alone outside the managed
section, and writes an `--agents-template` as given.
- **`bd setup claude` no longer rewrites a CLAUDE.md whose beads section is
already current.** A rerun (and `bd init`, which runs it) wrote the same
bytes back as a new file, resetting its mode to 0644 and its mtime, and
reported "Updated existing beads section"; it now leaves the file alone and
reports the section current (the report `bd init` already gives a current
AGENTS.md). `bd setup factory`, `opencode`, `mux` and `gemini` share the
fix. A section whose END marker is missing or comes before BEGIN, which was
also reported as updated while nothing changed, is now reported as an error:
`bd setup factory`, `opencode` and `mux` exit 1 (`mux` before installing its
`.mux` hooks), while `claude` and `gemini` warn and carry on. When CLAUDE.md
is an `@AGENTS.md` stub and it is AGENTS.md that cannot be updated, `claude`
now names AGENTS.md in the warning and keeps the beads block left in the
stub, which it used to delete although AGENTS.md was never updated.
- **Time-bound filters and the keyset cursor compare the same instant on every
engine, whatever zone they are given in.** The storage filter builder binds
every time bound (`created_*`, `updated_*`, `closed_*`, `started_*`,
`defer_*`, `due_*`) as the UTC spelling of its instant. An engine whose
timestamp column carries no zone drops a literal's offset, so a `+02:00`
bound would have compared as that wall clock; Dolt already honored the
offset and `bd` resolves bounds to UTC, so no answer changes here. The
keyset cursor (`AfterCreatedAt`) is now bound in UTC too: embedded Dolt's
driver sends a `time.Time` as its wall clock with no zone, so a library
caller paging with a cursor in another zone was answered from the wrong
position there (server Dolt was unaffected).
- **`bd setup claude --global` keeps its beads section in `~/.claude/CLAUDE.md`.**
It wrote the section into the current directory's `CLAUDE.md`: run from your
home directory it created `~/CLAUDE.md`, which by default stops Claude Code
reading `AGENTS.md` in the projects below it, and `--remove --global`
stripped the section a project's own install had put in its `CLAUDE.md`
while leaving that project's hooks in place. A global install and removal now
use only the user-level files beside `~/.claude/settings.json`. A new
`~/.claude/CLAUDE.md` holds just the section, rendered the same whichever
project you run from. Claude Code loads that file in every project, so its
section, task-tracking rules included, applies only in repositories that use
beads. With global or plugin hooks `--check` accepts it when the project's
instructions have none, or names `--global` when it is missing and the
project has no `CLAUDE.md` of its own. Run from `~/.claude`,
or from your home directory unless `~/CLAUDE.md` still holds a section an
earlier run left there, `--check` judges the user-level files, and from your
home directory it names `--global` when no hooks are installed. From your
home directory, whose `.claude/settings.json` is the global one, `--remove`
removes the user-level section with the hooks. If you ran `--global` before,
re-run `bd setup claude --global` to add the section to `~/.claude/CLAUDE.md`.
A section an earlier `--global` run left in a directory's `CLAUDE.md` stays
there; delete it by hand if you don't want it.
- **`bd blocked --label`, `--label-any` and `--exclude-label` apply to a row
blocked only by an unsatisfied `external:` dependency.** The
external-dependency policy lists such a row itself, after the label query
has run, and it was listed whatever its labels; it is now narrowed by the
label filters like every other row, on every route. On the proxied-server
route such a row also printed with no labels; it now prints them.
- **`bd gate add-waiter` survives contention the store gave up replaying.**
It retried only a version miss, so a convoy adder failed when its guarded
write ended in a serialization failure or deadlock the backend stopped
replaying (Dolt/MySQL 1213/1205, Postgres 40001/40P01), or, over HTTP, in a
503 busy. Those are now retried, but at most twice: each arrives only after
the store or `bd serve` has spent a whole replay budget on the write (up to
15s), so the 20-write bound a version miss gets could hold an adder for
minutes. Each retry waits the jittered backoff plus a busy answer's
Retry-After, as `bd serve` sent it. The retry is safe because every round
re-reads the gate, deduplicates and writes the whole list guarded by the
version it read: a 503 is not proof that nothing was written (a gateway can
answer one after the commit), and a write that did land is found on the
re-read, so the waiter is never added twice; when the last write allowed is
answered busy, one more read checks for it before the command fails. A
server fault (500) and an unreachable database are still returned at once,
and once the retries run out the error says no write was confirmed and
names the write contention, instead of saying the gate kept changing.
- `bd list --title-contains X` works against an HTTP workspace. The client
folds it onto the listing's existing `title` parameter (the store compiles
both flags to the same case-insensitive substring predicate), so it needs
the `issues.list.title` capability, like `--title`. A `--title` and a
`--title-contains` that differ other than in letter case are two
predicates, so they ride `title` and `title_contains` together and also
need `issues.list.filters` (see Added), as does the `--closed-after` in
gascity's polecat pre-flight lookup of recently closed beads. Either flag
with `--parent` in the default tree view still refuses over HTTP.
- **`bd gate create`, `bd gate add-waiter` and `bd gate discover` work over a
connected HTTP workspace.** They wrote through the legacy `CreateIssue`,
`AddDependency` and map-based `UpdateIssue`, which the HTTP store does not
implement, so each failed before any gate member reached the wire. They now
run through the library roles on every route:
- `bd gate create` is ONE `Lifecycle.Create` carrying the gate members and
a reverse `blocks` edge from the blocked issue to the new gate, so the
gate and its edge land atomically (one `createIssue` over HTTP, behind
`issues.create.gates`). The direct route used to make two writes and an
explicit commit; the proxied-server route now uses the same role.
- `bd gate add-waiter` reads the gate through `Reader.Get`, deduplicates,
and writes the whole waiter list through `Lifecycle.Update` guarded by
the row version it read. On a version mismatch it re-reads and retries
after a jittered, doubling backoff (10 ms up to 400 ms per wait, at most
20 writes), so a convoy of workers registering on one gate at once all
succeed. On the direct route concurrent adders used to lose
each other's waiters while every one exited 0; no waiter is lost now.
Over HTTP it needs `issues.update.gates`.
- `bd gate discover` lists through `issueops.ListGates` (as `bd gate check`
does) and records each discovered run ID through `Lifecycle.Update`, the
same `await_id` write `bd gate check` and `bd close` make. Over HTTP it
needs `issues.update.gates`. Its summary now counts only the gates whose
run ID was recorded, and it exits non-zero when any matched gate's write
failed (it used to report such a gate as updated and exit 0).
Against a server that does not advertise the token it needs, `bd gate
create` and `bd gate add-waiter` are refused before any write, naming the
token; `bd gate discover` writes nothing and reports the token as that
gate's error. The served corpus gains `mc-gate-create-timer`,
`mc-gate-check-timer-resolves`, `mc-gate-add-waiter` and
`mc-update-await-id` (pending until the reference server advertises the
gate tokens), pinned passing by `TestE2E_GatesOverHTTP`.
- **`bd import` no longer reports a failed dependency check as a skipped
dependency.** Import skips an edge the dependency checks refuse (a
self-dependency, a cycle, or a blocker that is the issue's own ancestor or
descendant) and reports it on a `Skipped dependency:` line, or in
`skipped_dependencies` with `--json`. It did the same when the check's own
query failed, for example on a timeout, a dropped connection or a statement
the backend could not run: the SQL error became the skip reason, and on
Dolt, where the transaction survives a failed statement, the import
committed without the edge and exited 0. Such an error now fails the
import. Refused edges are still skipped as before.
- **`bd mol bond <A> <B>` ignored prefix routing** — operand resolution now uses
the same routing fallback as `bd show`/`bd update`/`bd close`, so a bead that
lives in a routed store (a prefix-routed rig via `routes.jsonl`, or the
contributor planning store) resolves instead of failing with `'<id>' not found
as issue or formula`. Previously `bd mol bond` resolved operands
against the local store only, so `gt sling <bead> <rig>` — which cooks the
default formula and bonds it to a rig-routed bead — died at `bd mol bond` even
though `bd show <bead>` resolved the same ID. Resolution is write-intent: the
routed target opens writable and the bond commits where the bead lives. Two
operands that live in the same routed rig share one store handle and bond
normally; only a bond whose operands resolve to genuinely different databases
is rejected rather than written to the wrong one. As part of this change, an
auto-route — contributor, maintainer or default — now opens writable for the
commands that change an existing issue (`bd update`, `bd close`,
`bd comment`, `bd unclaim`, `bd dep` and the other routed mutation commands,
as well as `bd mol bond`), so the write commits where the issue lives: for a
contributor, in the planning repository, as the contributor workflow
documents. Every auto-route used to open read-only, so on an embedded
workspace these writes were refused. `bd unclaim` now opens a routed issue
writable, as `bd update --claim` does, and commits the release there; on an
embedded workspace `bd human respond` and `bd human dismiss` now record a
routed change as a Dolt commit in the routed repository instead of leaving it
uncommitted in that repository's working set. A routed
write, prefix or auto, never creates the target's database: an embedded
repository that has not been bootstrapped yet fails the write instead of
gaining an empty database that `bd bootstrap` would then take for the real
one. An auto-routed store, read or write, now opens the target's own
configured `dolt_database`, as a prefix route already did, even when
`BEADS_DOLT_SERVER_DATABASE` names the current workspace's database. An
auto-routed write refuses a target whose `metadata.json` is unreadable or
names no `dolt_database`, while a target with no `metadata.json` at all (a
planning repository nothing has been created in yet) opens the one embedded
database it holds, or its default database when it holds none or several; a
prefix route still requires the target's `dolt_database`. A
routing failure, such as an unreadable `routes.jsonl` or a
routed store that fails to open, is now reported as itself instead of as
`no issue found matching`. Same routing-parity fix as
[#3608](https://github.com/gastownhall/beads/issues/3608) for `bd close`.
Fixes [#4714](https://github.com/gastownhall/beads/issues/4714).
- **`bd gate check` works over a connected HTTP workspace.** Its open-gate
listing built the same raw `SearchIssues` filter `bd gate list` did before
S20, so the HTTP backend refused the command before reading a gate and gc's
@ -1142,31 +602,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
1,000 listed rows: +0.07 s at 1,000 rows and +0.46 s at 4,000 on embedded
Dolt. A store with many wisps, whose edges the old read also scanned, is
faster at every page size.
- A heartbeat can no longer resurrect a lease after a release or close. A
heartbeat re-arming a hand-doled claim (in_progress with no lease row) could
race a release or close on Dolt and leave an orphaned lease row on an open
or closed issue; every later heartbeat by the former holder then refreshed
it and answered success for a claim it no longer held. This affected every
Dolt route, including releases before this one. The re-arm is now recorded
as a mutation and remints the issue's row_lock, which every claim-ending
path rewrites, so it collides with a racing release or close and one side
is replayed against the other's result (the cost: a hand-doled claim's
first heartbeat changes its `revision` once). The refresh also requires, in
the same transaction, that the issue is still in_progress under the holder,
and a refusal deletes the caller's orphaned lease row, so a lease row
orphaned any other way never answers a heartbeat. A refresh and a refusal
still make no Dolt commit on any route; a re-arm commits only its own
tables (never `DOLT_COMMIT('-Am')`), so another writer's uncommitted
batch-mode edits to other tables stay uncommitted (a re-arm stages its
tables whole, as every other direct-route write does). On embedded Dolt, a heartbeat landing in
the same second as the previous one no longer re-grants the lease
(rewriting its `granted_at` / `granted_node`), and on every route a
heartbeat whose actor is a different spelling of the lease's holder
(`gastown.mayor` for `gastown__mayor`) refreshes the lease in place,
keeping its `granted_at` and granting replica, instead of re-granting it
under this node. For a Postgres port: the
refresh now reads the issue row, so under SERIALIZABLE expect more retried
serialization failures between a holder's own edits and its heartbeat.
- **`bd gate list` works over a connected HTTP workspace** (S20). The
workspace-wide listing built a raw `SearchIssues` filter, which the HTTP
backend refuses, so gc's `renudge-stale-human-gates` order failed on every

View file

@ -275,40 +275,16 @@ instead of 60s, because `bd serve` gives such a request its
`--large-apply-ceiling` (5 minutes by default) and finishes it even after the
client has given up. A server whose ceiling is raised past about 5m15s can
still outlast the client. A dial or TLS timeout stays a plain connection
error, since the server never saw the request, and a connect that fails says
so: it names the address that refused the connection (nothing listening) or
never answered (a filtered port or a down host, after the dialer's 30s), or
the host name that did not resolve. `off` turns off only the
error, since the server never saw the request. `off` turns off only the
header timer: a reset read is still retried, and a write's timeout is still
reported as above.
Whether the server applies bd's external-dependency policy itself (the
`policy.external_dependencies` capability) is remembered for 5 minutes per
server URL and pinned project, in `beads/http-policy/` under the user cache
directory, so `bd ready` does not fetch the server's context before every
listing just to learn it. `BEADS_HTTP_POLICY_CACHE_TTL` sets that window (a
duration such as `1m`, a number of seconds, or `off`); a server restarted
with a different composition is seen once it passes. Claims and closes never
use the cached answer: they ask the server, since a stale one could skip the
client-side refusal of externally blocked work. A workspace connected without
a project pin is not cached.
`bd search`, `bd show --current` and `bd recompute-blocked` work over HTTP
too, each in its own way. `bd search` asks the server's listing with its text (`q`, behind the `issues.list.search` capability) and
refuses before dialing against a server that does not advertise it. `bd list
--no-assignee`, `--title` and `--id` likewise ride the listing's
`no_assignee`, `title` and repeatable `id`, each behind its own capability
(`issues.list.noAssignee`, `issues.list.title`, `issues.list.ids`), and the
rest of `bd list`'s filters (`--updated-*`, `--closed-*`, `--defer-*`,
`--due-*`, `--priority*`, the text and external-ref matches, `--spec`,
`--label-pattern`/`--label-regex`, `--exclude-type`, `--no-parent`,
`--no-labels`, `--empty-description`, `--pinned`/`--no-pinned`,
`--deferred`, `--overdue`, `--mol-type`, `--wisp-type`) ride it behind one
capability, `issues.list.filters`. Time bounds are resolved on the client as
they are locally; `--overdue` compares against the server's clock. The
default `--parent` tree view does not carry those filters yet and refuses one
rather than drop it; `--flat` or `--json` applies them to the parent's direct
children (not its whole subtree).
(`issues.list.noAssignee`, `issues.list.title`, `issues.list.ids`).
`bd show --current` finds the actor's in-progress or hooked issue through the
server's boolean query. `bd recompute-blocked` is a no-op that exits 0: the
server maintains `is_blocked` on every write, and repairing a stale flag is

View file

@ -145,8 +145,7 @@ Before starting a release:
- [ ] All tests passing (`make test`, the Bazel test lane)
- [ ] npm package tests passing (`cd npm-package && npm run test:all`)
- [ ] **Upgrade smoke tests pass** (`make test-upgrade`) — see [Release Stability Gate](engdocs/RELEASE-STABILITY-GATE.md)
- [ ] **Regression tests pass**
(`bazel test //tests/regression:regression_test --config=doltserver-cmd`)
- [ ] **Regression tests pass** (`make test-regression`)
- [ ] **Every release target cross-compiles** — see
[Cross-compile before tagging](#cross-compile-before-tagging). PR CI
builds them only with cgo off, and a target that fails at tag time

View file

@ -19,7 +19,7 @@ Row numbers are the historical table's. Line numbers in this table are against t
| # | Path | Version seam at this head | Disposition | Mechanism |
|---|---|---|---|---|
| 13 | any of rows 1-8 whose target row is a wisp **or a promoted no-history bead** | no | NO-OP (a flagged issues-table create is stamped, not versioned) | The table that holds the row decides its plane, not its flags. A row in the wisps table mints and stamps nothing, whatever its flags say (FR-8). An update-shaped call on a flagged wisp returns on `IsWisp`, which is `Ephemeral \|\| NoHistory` (helpers.go:36-41). Every other wisps-table row is excluded by the seam's read of `participation_generation` from the issues table, which finds no row and returns: a flagged wisp's create-shaped call, and an unflagged row (bd mol squash's in-place flag clear, import's `wisp_plane` marker), which passes `IsWisp`. An issues-table row carrying `NoHistory` (a promoted no-history bead, bd-r9uce) is never versioned while it says so, because no-history means no history: an update-shaped call returns on `IsWisp`. A create-shaped call on such a row, with the flag on, still stamps `participation_generation` and mints nothing, so the row is not legacy once `bd update --persistent` repairs the flag in place. |
| 13 | any of rows 1-8 whose target row is a wisp **or a promoted no-history bead** | no | NO-OP | `RecordVersionInTx` returns on `IsWisp`, which is `Ephemeral \|\| NoHistory` (helpers.go:36-41): wisps per FR-8, and a promoted no-history bead — a durable issues-plane row with `NoHistory=true` — because no-history means no history. Wording only; the code did not change. |
| 14 | dependencies.go:`addDependencyInTx` via `AddDependencyInTx` from the store verbs, `ApplyParentPatch`, `applyBatchRun.applyDepAdd` | yes | VERSIONED | mint moved into `addDependencyInTx` (`mintDependencyVersion`, dependencies.go:393), gated on the row insert rather than on `eventWritten`; the publicops editor's own mint call was removed so no leg double-mints |
| 15 | domain/db/dependency.go:`dependencySQLRepositoryImpl.Insert` (uow `AddDependencies`, create-time edges) | yes | VERSIONED | seam at dependency.go:228 and :240 after the insert |
| 16 | dependencies.go:`removeDependencyInTx` via `RemoveDependencyInTx` and domain/db/dependency.go:`Delete` | yes | VERSIONED | gated on the row delete; dependency.go:409 on the uow leg |

View file

@ -15,7 +15,6 @@ go_library(
"batch_closer_contract.go",
"batch_creator_contract.go",
"batch_getter_contract.go",
"blocked_lister_contract.go",
"blocked_state.go",
"blocking_annotator_contract.go",
"bootstrapper_contract.go",
@ -29,11 +28,9 @@ go_library(
"deleter_contract.go",
"dependency_editor_contract.go",
"dualwrite_history_contract.go",
"dualwrite_participation_generation_contract.go",
"edge_reader_contract.go",
"expected_revision_contract.go",
"graph_counter_contract.go",
"heartbeater_contract.go",
"history_matching.go",
"importer_contract.go",
"issue_operations_contract.go",
@ -65,7 +62,6 @@ go_library(
"transaction_parity.go",
"tree_walker_contract.go",
"version_reconciler_contract.go",
"versioned_read_contract.go",
"workspaceconfig_contract.go",
],
importpath = "github.com/steveyegge/beads/backend/conformance",

View file

@ -1,426 +0,0 @@
package conformance
import (
"context"
"fmt"
"reflect"
"slices"
"testing"
"time"
"github.com/steveyegge/beads/internal/types"
publicops "github.com/steveyegge/beads/issueops"
)
// This file holds the semantic contract every implementation of
// publicops.BlockedLister must satisfy: what issueops/blockedlister.go
// promises, asserted on every leg (dolt, embedded dolt, unit of work, and the
// served HTTP client) so `bd blocked` answers one listing whichever route it
// takes.
//
// EVERY CASE IS SCOPED BY A LABEL: the blocked set is a property of the whole
// database, not of an id prefix, so a row seeded by one case is inside the
// next one's answer unless each asks through Labels.
// BlockedListerFixture supplies adapter-specific storage access for the
// blocked-listing assertions.
type BlockedListerFixture struct {
// IssuePrefix namespaces the ids each case seeds, so several cases can
// share one database.
IssuePrefix string
// BlockedLister is the surface under test.
BlockedLister publicops.BlockedLister
// CreateIssue seeds a durable issue in the issues plane.
CreateIssue func(context.Context, *types.Issue, string) error
// CreateWisp seeds an ephemeral issue in the wisps plane.
CreateWisp func(context.Context, *types.Issue, string) error
// AddDependency seeds ONE edge, recomputing the stored blocked flag the
// way every dependency write does.
AddDependency func(context.Context, *types.Dependency, string) error
// MarkBlocked sets the stored is_blocked flag on one durable issue
// directly, without the edge that would justify it: the stale flag `bd
// recompute-blocked` exists to repair. It must fail unless exactly one row
// changed. A nil hook means this leg cannot write the column, and the case
// that needs it skips with that reason.
MarkBlocked func(context.Context, string) error
}
// RunBlockedLister runs every blocked-listing case as a subtest of t.
func RunBlockedLister(t *testing.T, ctx context.Context, fixture BlockedListerFixture) {
t.Helper()
t.Run("NamesADirectBlocker", func(t *testing.T) { runBlockedNamesADirectBlocker(t, ctx, fixture) })
t.Run("AttributesAChildToItsBlockedParent", func(t *testing.T) { runBlockedAttributesAChildToItsParent(t, ctx, fixture) })
t.Run("ClosedBlockerDoesNotBlock", func(t *testing.T) { runBlockedClosedBlockerDoesNotBlock(t, ctx, fixture) })
t.Run("IncludesTheWispPlane", func(t *testing.T) { runBlockedIncludesTheWispPlane(t, ctx, fixture) })
t.Run("ExcludesThePinnedStatus", func(t *testing.T) { runBlockedExcludesThePinnedStatus(t, ctx, fixture) })
t.Run("ParentFilter", func(t *testing.T) { runBlockedParentFilter(t, ctx, fixture) })
t.Run("LabelFilters", func(t *testing.T) { runBlockedLabelFilters(t, ctx, fixture) })
t.Run("Order", func(t *testing.T) { runBlockedOrder(t, ctx, fixture) })
t.Run("NamesWaitsForAndConditionalBlockers", func(t *testing.T) { runBlockedNamesWaitsForAndConditionalBlockers(t, ctx, fixture) })
t.Run("OmitsAStaleFlagWithNoNameableBlocker", func(t *testing.T) { runBlockedOmitsAStaleFlag(t, ctx, fixture) })
t.Run("HasNoTypeExclusions", func(t *testing.T) { runBlockedHasNoTypeExclusions(t, ctx, fixture) })
t.Run("EmptyIsAnEmptySlice", func(t *testing.T) { runBlockedEmptyIsAnEmptySlice(t, ctx, fixture) })
t.Run("DoesNotMutateTheCallerRequest", func(t *testing.T) { runBlockedDoesNotMutateTheRequest(t, ctx, fixture) })
}
// runBlockedNamesADirectBlocker: an issue with an open `blocks` target is
// listed with that target as its one blocker; the target itself is not.
func runBlockedNamesADirectBlocker(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-direct"
blocked, blocker := blListerID(f, "direct-src"), blListerID(f, "direct-dst")
blListerSeedIssue(t, ctx, f, blListerIssue(blocked, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label))
blListerSeedEdge(t, ctx, f, blocked, blocker, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{blocked: {blocker}})
}
// runBlockedAttributesAChildToItsParent: a child of a blocked parent, with no
// blocker of its own, is listed with its parent named as the blocker.
func runBlockedAttributesAChildToItsParent(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-child"
parent, child, blocker := blListerID(f, "child-parent"), blListerID(f, "child-child"), blListerID(f, "child-blocker")
blListerSeedIssue(t, ctx, f, blListerIssue(parent, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(child, 1, label))
blListerSeedEdge(t, ctx, f, child, parent, types.DepParentChild)
blListerSeedEdge(t, ctx, f, parent, blocker, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{parent: {blocker}, child: {parent}})
}
// runBlockedClosedBlockerDoesNotBlock: a `blocks` edge onto a closed target
// names no blocker, so the source is not listed.
func runBlockedClosedBlockerDoesNotBlock(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-closed"
src, dst := blListerID(f, "closed-src"), blListerID(f, "closed-dst")
blListerSeedIssue(t, ctx, f, blListerIssue(src, 1, label))
closed := blListerIssue(dst, 1, label)
closed.Status = types.StatusClosed
blListerSeedIssue(t, ctx, f, closed)
blListerSeedEdge(t, ctx, f, src, dst, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{})
}
// runBlockedIncludesTheWispPlane: a blocked wisp is listed beside the issues.
func runBlockedIncludesTheWispPlane(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-wisp"
wisp, blocker := blListerID(f, "wisp-src"), blListerID(f, "wisp-dst")
w := blListerIssue(wisp, 1, label)
w.Ephemeral = true
if err := f.CreateWisp(ctx, w, "seed"); err != nil {
t.Fatalf("seed wisp %s: %v", wisp, err)
}
b := blListerIssue(blocker, 1, label)
b.Ephemeral = true
if err := f.CreateWisp(ctx, b, "seed"); err != nil {
t.Fatalf("seed wisp %s: %v", blocker, err)
}
blListerSeedEdge(t, ctx, f, wisp, blocker, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{wisp: {blocker}})
}
// runBlockedExcludesThePinnedStatus: a row whose status is pinned is never
// listed, whatever blocks it.
func runBlockedExcludesThePinnedStatus(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-pinned"
pinned, open, blocker := blListerID(f, "pinned-src"), blListerID(f, "pinned-open"), blListerID(f, "pinned-dst")
p := blListerIssue(pinned, 1, label)
p.Status = types.StatusPinned
blListerSeedIssue(t, ctx, f, p)
blListerSeedIssue(t, ctx, f, blListerIssue(open, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
blListerSeedEdge(t, ctx, f, pinned, blocker, types.DepBlocks)
blListerSeedEdge(t, ctx, f, open, blocker, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{open: {blocker}})
}
// runBlockedParentFilter: ParentID narrows to the parent's direct children.
func runBlockedParentFilter(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-parent"
parent, kid, stranger, blocker := blListerID(f, "pf-parent"), blListerID(f, "pf-kid"), blListerID(f, "pf-stranger"), blListerID(f, "pf-blocker")
blListerSeedIssue(t, ctx, f, blListerIssue(parent, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(kid, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(stranger, 1, label))
blListerSeedEdge(t, ctx, f, kid, parent, types.DepParentChild)
blListerSeedEdge(t, ctx, f, kid, blocker, types.DepBlocks)
blListerSeedEdge(t, ctx, f, stranger, blocker, types.DepBlocks)
all := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, all, map[string][]string{kid: {blocker}, stranger: {blocker}})
narrowed := blListerList(t, ctx, f, publicops.BlockedRequest{ParentID: parent, Labels: []string{label}})
blListerAssertRows(t, narrowed, map[string][]string{kid: {blocker}})
}
// runBlockedLabelFilters: Labels is AND, LabelsAny is OR, ExcludeLabels
// removes, and every value is trimmed with blanks dropped.
func runBlockedLabelFilters(t *testing.T, ctx context.Context, f BlockedListerFixture) {
base := f.IssuePrefix + "-bl-lab"
red, blue := base+"-red", base+"-blue"
both, onlyRed, onlyBlue, blocker := blListerID(f, "lab-both"), blListerID(f, "lab-red"), blListerID(f, "lab-blue"), blListerID(f, "lab-blocker")
blListerSeedIssue(t, ctx, f, blListerIssue(both, 1, base, red, blue))
blListerSeedIssue(t, ctx, f, blListerIssue(onlyRed, 1, base, red))
blListerSeedIssue(t, ctx, f, blListerIssue(onlyBlue, 1, base, blue))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, base+"-other"))
for _, id := range []string{both, onlyRed, onlyBlue} {
blListerSeedEdge(t, ctx, f, id, blocker, types.DepBlocks)
}
want := func(ids ...string) map[string][]string {
m := map[string][]string{}
for _, id := range ids {
m[id] = []string{blocker}
}
return m
}
blListerAssertRows(t, blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{" " + red + " ", "", blue}}), want(both))
blListerAssertRows(t, blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{base}, LabelsAny: []string{red, blue}}), want(both, onlyRed, onlyBlue))
blListerAssertRows(t, blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{base}, ExcludeLabels: []string{" " + blue}}), want(onlyRed))
}
// runBlockedOrder: priority ascending, then created_at descending, then id.
//
// The created_at values are seeded explicitly, so every key decides at least
// one pair: two rows share a priority and differ in created_at (newest first),
// and five share both priority and created_at (the id breaks the tie). The
// expected order is written out rather than recomputed from the answer.
func runBlockedOrder(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-order"
blocker := blListerID(f, "order-blocker")
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
older := time.Date(2026, 1, 1, 10, 0, 0, 0, time.UTC)
newer := older.Add(time.Hour)
// Two of the five tied rows are wisps. The store body assembles rows
// issues-plane first, each plane in id order, so the ids alone would put
// the tied run in the wrong order (b, d, e, then a, c); only the id
// tiebreak puts it right.
rows := []struct {
name string
priority int
created time.Time
wisp bool
}{
{"order-p3", 3, newer, false},
{"order-p0-older", 0, older, false},
{"order-p0-newer-e", 0, newer, false},
{"order-p0-newer-c", 0, newer, true},
{"order-p0-newer-a", 0, newer, true},
{"order-p0-newer-d", 0, newer, false},
{"order-p0-newer-b", 0, newer, false},
{"order-p1", 1, older, false},
}
for _, row := range rows {
issue := blListerIssue(blListerID(f, row.name), row.priority, label)
issue.CreatedAt = row.created
issue.UpdatedAt = row.created
if row.wisp {
issue.Ephemeral = true
if err := f.CreateWisp(ctx, issue, "seed"); err != nil {
t.Fatalf("seed wisp %s: %v", issue.ID, err)
}
} else {
blListerSeedIssue(t, ctx, f, issue)
}
blListerSeedEdge(t, ctx, f, issue.ID, blocker, types.DepBlocks)
}
want := []string{
blListerID(f, "order-p0-newer-a"),
blListerID(f, "order-p0-newer-b"),
blListerID(f, "order-p0-newer-c"),
blListerID(f, "order-p0-newer-d"),
blListerID(f, "order-p0-newer-e"),
blListerID(f, "order-p0-older"),
blListerID(f, "order-p1"),
blListerID(f, "order-p3"),
}
got := blListerIDs(blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}}))
if !slices.Equal(got, want) {
t.Errorf("listing order = %v, want %v (priority ascending, created_at descending, id)", got, want)
}
}
// runBlockedNamesWaitsForAndConditionalBlockers: a waits-for onto a spawner
// whose child is still open, and a conditional-blocks onto an open target,
// each name their target, as a blocks edge does.
func runBlockedNamesWaitsForAndConditionalBlockers(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-wf"
spawner, spawned := blListerID(f, "wf-spawner"), blListerID(f, "wf-spawned")
waiter := blListerID(f, "wf-waiter")
target, conditional := blListerID(f, "cb-target"), blListerID(f, "cb-src")
blListerSeedIssue(t, ctx, f, blListerIssue(spawner, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(spawned, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(target, 1, label+"-other"))
blListerSeedIssue(t, ctx, f, blListerIssue(waiter, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(conditional, 1, label))
blListerSeedEdge(t, ctx, f, spawned, spawner, types.DepParentChild)
blListerSeedEdge(t, ctx, f, waiter, spawner, types.DepWaitsFor)
blListerSeedEdge(t, ctx, f, conditional, target, types.DepConditionalBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{waiter: {spawner}, conditional: {target}})
}
// runBlockedOmitsAStaleFlag: a row whose stored flag says blocked but which
// has no active blocker and no parent names no blocker, so it is not listed.
// This is the narrowing gc's readiness projection documents relying on.
func runBlockedOmitsAStaleFlag(t *testing.T, ctx context.Context, f BlockedListerFixture) {
if f.MarkBlocked == nil {
t.Skip("this leg cannot write the stored is_blocked flag directly")
}
label := f.IssuePrefix + "-bl-stale"
stale, real, blocker := blListerID(f, "stale-src"), blListerID(f, "stale-real"), blListerID(f, "stale-blocker")
blListerSeedIssue(t, ctx, f, blListerIssue(stale, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(real, 1, label))
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
blListerSeedEdge(t, ctx, f, real, blocker, types.DepBlocks)
if err := f.MarkBlocked(ctx, stale); err != nil {
t.Fatalf("mark %s blocked: %v", stale, err)
}
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{real: {blocker}})
}
// runBlockedHasNoTypeExclusions: a gate is listed like any other row; the
// blocked door excludes no issue type (unlike the ready front).
func runBlockedHasNoTypeExclusions(t *testing.T, ctx context.Context, f BlockedListerFixture) {
label := f.IssuePrefix + "-bl-type"
gate, epic, blocker := blListerID(f, "type-gate"), blListerID(f, "type-epic"), blListerID(f, "type-blocker")
g := blListerIssue(gate, 1, label)
g.IssueType = types.TypeGate
g.AwaitType = "human"
blListerSeedIssue(t, ctx, f, g)
e := blListerIssue(epic, 1, label)
e.IssueType = types.TypeEpic
blListerSeedIssue(t, ctx, f, e)
blListerSeedIssue(t, ctx, f, blListerIssue(blocker, 1, label+"-other"))
blListerSeedEdge(t, ctx, f, gate, blocker, types.DepBlocks)
blListerSeedEdge(t, ctx, f, epic, blocker, types.DepBlocks)
items := blListerList(t, ctx, f, publicops.BlockedRequest{Labels: []string{label}})
blListerAssertRows(t, items, map[string][]string{gate: {blocker}, epic: {blocker}})
}
// runBlockedEmptyIsAnEmptySlice: nothing blocked is an empty, non-nil slice
// and a nil error.
func runBlockedEmptyIsAnEmptySlice(t *testing.T, ctx context.Context, f BlockedListerFixture) {
result, err := f.BlockedLister.ListBlocked(ctx, publicops.BlockedRequest{Labels: []string{f.IssuePrefix + "-bl-nothing"}})
if err != nil {
t.Fatalf("ListBlocked: %v", err)
}
if result.Items == nil || len(result.Items) != 0 {
t.Fatalf("Items = %#v, want an empty non-nil slice", result.Items)
}
}
// runBlockedDoesNotMutateTheRequest: the caller's label slices come back as
// they were sent, normalization notwithstanding.
func runBlockedDoesNotMutateTheRequest(t *testing.T, ctx context.Context, f BlockedListerFixture) {
req := publicops.BlockedRequest{
ParentID: " ",
Labels: []string{" a ", "", "a"},
LabelsAny: []string{" b"},
ExcludeLabels: []string{"c "},
}
before := publicops.BlockedRequest{
ParentID: req.ParentID,
Labels: slices.Clone(req.Labels),
LabelsAny: slices.Clone(req.LabelsAny),
ExcludeLabels: slices.Clone(req.ExcludeLabels),
}
if _, err := f.BlockedLister.ListBlocked(ctx, req); err != nil {
t.Fatalf("ListBlocked: %v", err)
}
if !reflect.DeepEqual(req, before) {
t.Errorf("request after = %#v, before = %#v", req, before)
}
}
func blListerID(f BlockedListerFixture, name string) string {
return fmt.Sprintf("%s-%s", f.IssuePrefix, name)
}
func blListerIssue(id string, priority int, labels ...string) *types.Issue {
return &types.Issue{
ID: id,
Title: id,
Status: types.StatusOpen,
Priority: priority,
IssueType: types.TypeTask,
Labels: labels,
}
}
func blListerSeedIssue(t *testing.T, ctx context.Context, f BlockedListerFixture, issue *types.Issue) {
t.Helper()
if err := f.CreateIssue(ctx, issue, "seed"); err != nil {
t.Fatalf("seed issue %s: %v", issue.ID, err)
}
}
func blListerSeedEdge(t *testing.T, ctx context.Context, f BlockedListerFixture, from, to string, kind types.DependencyType) {
t.Helper()
if err := f.AddDependency(ctx, &types.Dependency{IssueID: from, DependsOnID: to, Type: kind}, "seed"); err != nil {
t.Fatalf("seed %s edge %s -> %s: %v", kind, from, to, err)
}
}
func blListerList(t *testing.T, ctx context.Context, f BlockedListerFixture, req publicops.BlockedRequest) []*types.BlockedIssue {
t.Helper()
result, err := f.BlockedLister.ListBlocked(ctx, req)
if err != nil {
t.Fatalf("ListBlocked(%+v): %v", req, err)
}
if result.Items == nil {
t.Fatalf("ListBlocked(%+v) Items is nil; the role promises a non-nil slice", req)
}
return result.Items
}
func blListerIDs(items []*types.BlockedIssue) []string {
ids := make([]string, 0, len(items))
for _, item := range items {
ids = append(ids, item.ID)
}
return ids
}
// assertBlockedRows requires the listing to be exactly want: the same ids,
// each naming exactly the blockers want gives it (in any order), with
// BlockedByCount equal to their number.
func blListerAssertRows(t *testing.T, items []*types.BlockedIssue, want map[string][]string) {
t.Helper()
got := map[string][]string{}
for _, item := range items {
if item == nil {
t.Fatalf("listing carries a nil row")
}
if _, dup := got[item.ID]; dup {
t.Errorf("row %s listed twice", item.ID)
}
blockers := slices.Clone(item.BlockedBy)
slices.Sort(blockers)
got[item.ID] = blockers
if item.BlockedByCount != len(item.BlockedBy) {
t.Errorf("row %s: BlockedByCount = %d, len(BlockedBy) = %d", item.ID, item.BlockedByCount, len(item.BlockedBy))
}
}
normalized := map[string][]string{}
for id, blockers := range want {
b := slices.Clone(blockers)
slices.Sort(b)
normalized[id] = b
}
if !reflect.DeepEqual(got, normalized) {
t.Errorf("listing = %v, want %v", got, normalized)
}
}

View file

@ -71,13 +71,11 @@ import (
// - PARTICIPATION-GENERATION GATING (design §16.2b). Whether an
// update-shaped mutation on a legacy (participation_generation IS NULL)
// row is correctly skipped is Phase 2 behavior this bead also owns, but
// it depends on migration 0070's participation_generation column, which
// does not exist when this contract is first written (0070 lands last in
// this bead's build order, by the mayor's explicit sequencing — steps 4-5
// of design §16.3 moved to their own migration slot when 0068 shipped as
// attribution_status-only, see that migration's header). It gets its own
// dedicated cases once 0070 lands, beside this file rather than inside
// it.
// it depends on migration 0068's participation_generation column, which
// does not exist when this contract is first written (0068 lands last in
// this bead's build order, by the mayor's explicit sequencing). It gets
// its own dedicated cases once 0068 lands, beside this file rather than
// inside it.
// - CONCURRENT WRITERS. Every case here is one writer, one issue, one
// mutation at a time — the same restriction journal_contract.go states
// for the same reason: a single-threaded case cannot exercise what only

View file

@ -1,644 +0,0 @@
package conformance
import (
"context"
"testing"
)
// This file holds the write-fence cases dualwrite_history_contract.go's own
// "WHAT THIS CONTRACT DELIBERATELY DOES NOT PIN" section explicitly deferred:
// "PARTICIPATION-GENERATION GATING (design §16.2b)... It gets its own
// dedicated cases once 0070 lands, beside this file rather than inside it."
// Migration 0070 now carries participation_generation on both issues and
// wisps (design §16.3 steps 4-5, be-dt74u amendment, be-h89oq), so this is
// that file.
//
// Design §16.2b, verbatim substance: the flag-on writer does not increment
// current_revision or mint an issue_versions row for an UPDATE-shaped
// mutation against a record whose participation_generation is NULL — a skip,
// not a refusal (FR-2's zero-rows no-op shape). A CREATE-shaped mutation is
// different: a brand-new row has no prior legacy state to preserve, so if the
// flag is already on at creation time, the writer stamps
// participation_generation as part of the same insert that begins its
// history. A create with the flag off leaves the column NULL, indistinguishable
// from a true legacy row (FR-7's byte-identical requirement).
//
// WHY A SEPARATE FIXTURE RATHER THAN THREE MORE DualWriteFixture CLOSURES.
// DualWriteFixture's Mutate/MutateAsNoOp pair is deliberately flag-fixed-at-
// construction (see that file's SEEDING DISCIPLINE note and each leg's
// newXxxDualWriteFixture, which calls SetVersionedHistoryEnabled exactly
// once). The legacy-record case here is inherently "created while the flag
// was OFF, then mutated after the flag turns ON" — a fixture built once with
// one flag state cannot express that sequence, so SetFlag here is a toggle
// callable more than once per fixture, not a one-time constructor argument.
//
// THE FIXTURE'S CLOSURES ARE THE OBSERVABLE SURFACE, NOT THE SCHEMA — same
// discipline as DualWriteFixture: Mutate/MutateExisting drive CreateIssue and
// UpdateIssue (or their unit-of-work equivalents), never issue_versions or
// store_epoch directly.
//
// WHAT THIS CONTRACT DELIBERATELY DOES NOT PIN:
// - THE EXACT STAMPED VALUE. That a create-shaped mutation with the flag on
// stamps SOME non-NULL participation_generation is pinned here; that the
// value equals the current store_epoch.epoch is not — reaching
// store_epoch is the same one-column, two-of-three-legs-need-white-box-
// access problem dualwrite_history_contract.go's FR-6 note describes, and
// the same resolution applies: pinned per leg, dolt-only, alongside
// TestDualWriteStampsTheCurrentStoreEpochOnEachVersionRow.
// - wisps.participation_generation. FR-8 (carried by dualwrite_history_contract.go's
// exclusion list) applies here too: this fixture's Mutate front door is
// CreateIssue against the issues table, the wisp-arrival cases read only
// the issues row a wisp becomes, and no phase reads or writes the wisps
// column regardless.
type ParticipationGenerationFixture struct {
// IssuePrefix namespaces the id each case mints, the same discipline
// DualWriteFixture uses and for the same reason.
IssuePrefix string
// SetFlag toggles versioned history for every subsequent call through
// this fixture, and may be called more than once per case — unlike
// DualWriteFixture, whose flag is fixed at construction.
SetFlag func(ctx context.Context, enabled bool) error
// Mutate creates a new issue with the given id: a CREATE-shaped mutation
// in design §16.2b's sense.
Mutate func(ctx context.Context, id string) error
// MutateExisting applies a real (non-no-op) UPDATE-shaped mutation to an
// already-existing issue — a different value than Mutate gave it, so a
// vacuous no-op skip can never be mistaken for the fence.
MutateExisting func(ctx context.Context, id string) error
// CreateWisp creates a new wisp-plane (ephemeral) issue with the given
// id: the starting point for the two ways a record reaches the issues
// plane without being created there. A wisp is never versioned (FR-8)
// and never carries a participation declaration, in either flag state.
CreateWisp func(ctx context.Context, id string) error
// PromoteWisp promotes the wisp id onto the issues plane
// (PromoteFromEphemeral, or the unit-of-work leg's PromoteWisp).
PromoteWisp func(ctx context.Context, id string) error
// MovePersistent moves the wisp id onto the issues plane through a
// persistence-mode update (bd update --persistent). It is its own
// closure rather than a second spelling of PromoteWisp because it mints at
// a different site on every leg: the guarded update's one end-of-update
// mint on dolt and embeddeddolt, MoveIssuePersistenceInTx's own on uow.
// On an issues-plane row whose flags disagree with it (see
// CreateNoHistoryIssue) the same update repairs the flags in place, a
// same-plane normalize, rather than moving the row.
MovePersistent func(ctx context.Context, id string) error
// ClearWispFlag clears the wisp id's ephemeral flag IN PLACE: the untyped
// UpdateIssue of {"wisp": false} bd mol squash makes on a squashed root
// (UpdateWisp on the unit-of-work leg, the way its molecule writer routes
// it). The row stays in the wisps table, now carrying neither Ephemeral
// nor NoHistory.
ClearWispFlag func(ctx context.Context, id string) error
// SquashWispRoot closes the wisp id and then clears its flag as
// ClearWispFlag does, both in ONE transaction: the shape bd mol squash's
// root auto-close takes, where an error from either write aborts both.
SquashWispRoot func(ctx context.Context, id string) error
// CreateUnflaggedWisp creates id in the wisps table with neither
// Ephemeral nor NoHistory set: import's "wisp_plane" marker, which pins
// the plane whatever the flags say (WispPlaneOverride = &true, through
// the batch create import runs), or on the unit-of-work leg CreateWisp,
// which routes by the call rather than by the flags.
CreateUnflaggedWisp func(ctx context.Context, id string) error
// CreateNoHistoryIssue creates id in the ISSUES table carrying
// NoHistory=true: import's promoted-no-history shape (bd-r9uce), a
// durable row whose stray flag is preserved while WispPlaneOverride =
// &false pins its plane, through the batch create import runs; or on the
// unit-of-work leg CreateIssue, which routes by the call.
CreateNoHistoryIssue func(ctx context.Context, id string) error
// CurrentRevision reads issues.current_revision for id.
CurrentRevision func(ctx context.Context, id string) (int64, error)
// VersionRowCount reads how many issue_versions rows exist for id.
VersionRowCount func(ctx context.Context, id string) (int, error)
// ParticipationGeneration reads issues.participation_generation for id,
// returning nil for SQL NULL.
ParticipationGeneration func(ctx context.Context, id string) (*int64, error)
// InWispsTable reports whether the wisps table holds a row for id: the
// precondition the wisps-table cases check, so they cannot pass on a row
// that a step moved to the issues table.
InWispsTable func(ctx context.Context, id string) (bool, error)
}
// RunParticipationGenerationCreateWithFlagOnStampsAValue pins design
// §16.2(a)/(b): a create-shaped mutation with the flag already on stamps a
// non-NULL participation_generation on the new row, as part of the same
// insert that begins its history — a brand-new row has no legacy state to
// preserve, so there is nothing to skip.
func RunParticipationGenerationCreateWithFlagOnStampsAValue(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-create-stamps"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
gen, err := fixture.ParticipationGeneration(ctx, id)
if err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
}
if gen == nil {
t.Errorf("participation_generation for %s is NULL immediately after a create-shaped mutation with "+
"the flag on, want a stamped non-NULL value: design §16.2b requires the writer to declare "+
"participation at insert time, since a brand-new row has no prior legacy state to preserve", id)
}
}
// RunParticipationGenerationCreateWithFlagOffLeavesLegacyNull pins the other
// half of design §16.2(b): a create-shaped mutation with the flag off leaves
// participation_generation NULL, indistinguishable from a true legacy row —
// flag-off must stay byte-identical to pre-Phase-2 behavior (FR-7).
func RunParticipationGenerationCreateWithFlagOffLeavesLegacyNull(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, false); err != nil {
t.Fatalf("disabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-create-flag-off"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
gen, err := fixture.ParticipationGeneration(ctx, id)
if err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
}
if gen != nil {
t.Errorf("participation_generation for %s = %d with the flag off at creation, want NULL: a "+
"flag-off create must remain indistinguishable from a true legacy row (design §16.2b)", id, *gen)
}
}
// RunParticipationGenerationSkipsUpdateOnLegacyRecord pins the write fence's
// central claim, design §16.2(b): the flag-on writer does not increment
// current_revision or mint an issue_versions row for an update-shaped
// mutation against a record whose participation_generation is NULL. The
// record must be a REAL legacy record — created while the flag was off, not
// merely one the fixture asserts is NULL — so this also re-confirms that
// precondition before trusting the rest of the case.
func RunParticipationGenerationSkipsUpdateOnLegacyRecord(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, false); err != nil {
t.Fatalf("disabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-legacy-skip"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
if gen, err := fixture.ParticipationGeneration(ctx, id); err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
} else if gen != nil {
t.Fatalf("participation_generation for %s = %d before the flag was ever turned on, want NULL — "+
"this case cannot test the legacy-record fence against a record that was never actually legacy",
id, *gen)
}
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
beforeRevision, err := fixture.CurrentRevision(ctx, id)
if err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
}
beforeCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterRevision, err := fixture.CurrentRevision(ctx, id)
if err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != beforeCount {
t.Errorf("version row count for %s went from %d to %d across an update-shaped mutation on a "+
"legacy (participation_generation IS NULL) record with the flag now on, want unchanged: "+
"design §16.2b requires the writer to skip minting for a record it has not positively "+
"promoted", id, beforeCount, afterCount)
}
if afterRevision != beforeRevision {
t.Errorf("current_revision for %s went from %d to %d across the same skipped mutation, want "+
"unchanged: a skip means neither half of RecordVersionInTx's write runs, not just the "+
"version-row half", id, beforeRevision, afterRevision)
}
}
// RunParticipationGenerationProceedsForPromotedRecord is the fence's
// not-vacuous check: an update-shaped mutation against a record whose
// participation_generation is ALREADY stamped (created with the flag on,
// i.e. positively declared, not legacy) must mint normally. Without this
// case, an implementation that skips every update unconditionally would
// still pass RunParticipationGenerationSkipsUpdateOnLegacyRecord.
func RunParticipationGenerationProceedsForPromotedRecord(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-promoted-proceeds"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
if gen, err := fixture.ParticipationGeneration(ctx, id); err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
} else if gen == nil {
t.Fatalf("participation_generation for %s is NULL immediately after a create with the flag on — "+
"this case cannot test the promoted-record path against a record that was never actually "+
"promoted", id)
}
beforeCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != beforeCount+1 {
t.Errorf("version row count for %s went from %d to %d across an update-shaped mutation on an "+
"already-promoted record, want exactly +1: the fence must skip only a legacy (NULL) record, "+
"not every update (design §16.2b)", id, beforeCount, afterCount)
}
}
// RunParticipationGenerationFlagOffSkipsUpdateOnParticipatingRecord pins the
// switch's off half for a record the fence would let through: created with
// the flag on (so participation_generation is stamped), then updated after
// the flag is turned back off, it must mint nothing. ProceedsForPromotedRecord
// shows the fence passes such a record, so only the flag stands between this
// update and a mint. No other case can see a writer that ignores the flag on
// updates: every other flag-off record is legacy, and the fence stops those
// first.
func RunParticipationGenerationFlagOffSkipsUpdateOnParticipatingRecord(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-flag-off-skip"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
if gen, err := fixture.ParticipationGeneration(ctx, id); err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
} else if gen == nil {
t.Fatalf("participation_generation for %s is NULL immediately after a create with the flag on — "+
"this case cannot test the flag against a record the fence would have stopped anyway", id)
}
if err := fixture.SetFlag(ctx, false); err != nil {
t.Fatalf("disabling versioned history: %v", err)
}
beforeRevision, err := fixture.CurrentRevision(ctx, id)
if err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
}
beforeCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterRevision, err := fixture.CurrentRevision(ctx, id)
if err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != beforeCount {
t.Errorf("version row count for %s went from %d to %d across an update-shaped mutation with the "+
"flag off, want unchanged: turning versioned history off stops minting for every record, "+
"including one that already participates", id, beforeCount, afterCount)
}
if afterRevision != beforeRevision {
t.Errorf("current_revision for %s went from %d to %d across the same update with the flag off, "+
"want unchanged", id, beforeRevision, afterRevision)
}
}
// RunParticipationGenerationWispPromotionBeginsHistory pins that promoting a
// wisp onto the issues plane is CREATE-shaped in design §16.2b's sense. (This
// is wisp promotion, PromoteFromEphemeral: not R2.3's promotion of a legacy
// record, which is what ProceedsForPromotedRecord's name refers to.) The
// issues row a promotion inserts is brand new on that plane, and the wisp
// behind it was never versioned and never declared participation (FR-8), so
// there is no legacy state to preserve: with the flag on, the promotion stamps
// participation_generation and mints the record's first version, as a create
// there would. Treated as UPDATE-shaped, the fence finds the new row NULL and
// skips, and because nothing stamps the column afterwards every later update
// skips too, so a record created with the flag on is never versioned at all.
func RunParticipationGenerationWispPromotionBeginsHistory(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
runWispArrivalBeginsHistory(t, ctx, fixture, "promote", fixture.PromoteWisp)
}
// RunParticipationGenerationWispPersistenceMoveBeginsHistory is
// RunParticipationGenerationWispPromotionBeginsHistory for the other way a
// wisp reaches the issues plane, a persistence-mode update (bd update
// --persistent). It needs its own case because it reaches a different mint
// site than promotion on every leg (see MovePersistent).
func RunParticipationGenerationWispPersistenceMoveBeginsHistory(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
runWispArrivalBeginsHistory(t, ctx, fixture, "move-persistent", fixture.MovePersistent)
}
// runWispArrivalBeginsHistory is the body the two wisp-arrival cases share:
// with the flag on, a wisp that arrives on the issues plane through arrive
// carries a stamped participation_generation and exactly one version row,
// and the next update-shaped mutation mints normally.
func runWispArrivalBeginsHistory(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture, how string, arrive func(context.Context, string) error) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-" + how
if err := fixture.CreateWisp(ctx, id); err != nil {
t.Fatalf("creating wisp %s: %v", id, err)
}
if err := arrive(ctx, id); err != nil {
t.Fatalf("moving wisp %s onto the issues plane (%s): %v", id, how, err)
}
gen, err := fixture.ParticipationGeneration(ctx, id)
if err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
}
if gen == nil {
t.Errorf("participation_generation for %s is NULL after the wisp reached the issues plane (%s) with "+
"the flag on, want a stamped value: the issues row is new, so the arrival is create-shaped "+
"(design §16.2b), and a NULL here leaves the record fenced as legacy for good", id, how)
}
arrivedCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if arrivedCount != 1 {
t.Errorf("version row count for %s = %d after the wisp reached the issues plane (%s) with the flag "+
"on, want 1: a wisp is never versioned (FR-8), so the arrival mints the record's first version",
id, arrivedCount, how)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != arrivedCount+1 {
t.Errorf("version row count for %s went from %d to %d across an update-shaped mutation after the "+
"wisp reached the issues plane (%s), want exactly +1: a record that arrived with the flag on is "+
"not legacy, so the fence must let its updates mint", id, arrivedCount, afterCount, how)
}
}
// RunParticipationGenerationWispFlagClearMintsNothing pins that the fence
// decides a row's plane by the TABLE that holds it, not by the row's flags.
// bd mol squash clears a wisp root's ephemeral flag in place, so the row
// stays in the wisps table carrying neither Ephemeral nor NoHistory, and a
// plane test read off those flags takes it for an issues-plane row. It is
// not one: a wisps-table row is never versioned (FR-8) and has no issues row
// whose participation_generation the fence could read. So the update must
// succeed and mint nothing. Read off the flags, the fence either aborts the
// whole update looking for an issues row that is not there, or, without the
// fence, mints a stray version for a wisp.
func RunParticipationGenerationWispFlagClearMintsNothing(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
runWispTableRowMintsNothing(t, ctx, fixture, "flag-clear", fixture.CreateWisp, fixture.ClearWispFlag)
}
// RunParticipationGenerationWispRootSquashMintsNothing is
// RunParticipationGenerationWispFlagClearMintsNothing in the shape bd mol
// squash actually runs it: the root's close and its flag clear in one
// transaction, so a mint that fails on the cleared row takes the close down
// with it and the squash cannot complete.
func RunParticipationGenerationWispRootSquashMintsNothing(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
runWispTableRowMintsNothing(t, ctx, fixture, "squash", fixture.CreateWisp, fixture.SquashWispRoot)
}
// RunParticipationGenerationUnflaggedWispCreateMintsNothing pins the
// create-shaped half of the same rule: a row CREATED in the wisps table
// without either flag (import's "wisp_plane" marker) reaches the
// create-shaped mint, and must come out of it with no error and no version,
// exactly as a flagged wisp does.
func RunParticipationGenerationUnflaggedWispCreateMintsNothing(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
runWispTableRowMintsNothing(t, ctx, fixture, "unflagged-create", fixture.CreateUnflaggedWisp)
}
// runWispTableRowMintsNothing is the body the three wisps-table cases share:
// with the flag on, every step succeeds on id, the wisps table still holds id
// afterwards, and id ends with no issue_versions row.
func runWispTableRowMintsNothing(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture, how string, steps ...func(context.Context, string) error) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-" + how
for i, step := range steps {
if err := step(ctx, id); err != nil {
t.Fatalf("step %d of %s on wisps-table row %s with the flag on: %v — a row the wisps table "+
"holds is never versioned (FR-8), so its mint must be a no-op, not an error that aborts "+
"the mutation", i+1, how, id, err)
}
}
// The precondition, checked after the steps rather than assumed: a step
// that moved the row to the issues table would leave a NULL
// participation_generation there, the update-shaped mint would be fenced
// as legacy, and the zero count below would hold without saying anything
// about a wisps-table row.
if inWisps, err := fixture.InWispsTable(ctx, id); err != nil {
t.Fatalf("checking whether the wisps table holds %s: %v", id, err)
} else if !inWisps {
t.Fatalf("%s is not in the wisps table after %s — this case pins that a wisps-table row mints "+
"nothing, and cannot say so about a row a step moved out of that table", id, how)
}
count, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if count != 0 {
t.Errorf("version row count for wisps-table row %s = %d after %s with the flag on, want 0: a "+
"wisp is never versioned (FR-8), whatever its flags say", id, count, how)
}
}
// RunParticipationGenerationNoHistoryIssueCreateDeclaresParticipation pins
// that a create declares participation for every ISSUES-table row it makes
// with the flag on, a row carrying NoHistory included. Import keeps a
// promoted no-history wisp's durable row on the issues plane with its stray
// no_history=true (bd-r9uce). While the row says no-history it is not
// versioned, so the create mints nothing. But it was created with history
// on, so it is not legacy: once bd update --persistent repairs the flag in
// place (a same-plane normalize, update-shaped by design), the repair and
// every update after it must mint. Left NULL by the create, the column reads
// as legacy to the fence, and the row is never versioned at all.
func RunParticipationGenerationNoHistoryIssueCreateDeclaresParticipation(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-no-history-create"
if err := fixture.CreateNoHistoryIssue(ctx, id); err != nil {
t.Fatalf("creating no-history issues-plane row %s: %v", id, err)
}
gen, err := fixture.ParticipationGeneration(ctx, id)
if err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
}
if gen == nil {
t.Errorf("participation_generation for %s is NULL after a create with the flag on, want a stamped "+
"value: the row is new on the issues plane, so the create declares participation (design "+
"§16.2b) even though its NoHistory flag keeps it unversioned for now", id)
}
if count, err := fixture.VersionRowCount(ctx, id); err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
} else if count != 0 {
t.Errorf("version row count for %s = %d after a create carrying NoHistory, want 0: a no-history "+
"row is not versioned while it says so", id, count)
}
if err := fixture.MovePersistent(ctx, id); err != nil {
t.Fatalf("repairing %s to persistent: %v", id, err)
}
repairedCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if repairedCount != 1 {
t.Errorf("version row count for %s = %d after the persistent repair, want 1: the row was created "+
"with the flag on, so the fence must let the repair's update-shaped mint through", id, repairedCount)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != repairedCount+1 {
t.Errorf("version row count for %s went from %d to %d across an update-shaped mutation after the "+
"repair, want exactly +1", id, repairedCount, afterCount)
}
}
// RunParticipationGenerationLegacyNoHistoryIssueStaysLegacy is
// RunParticipationGenerationNoHistoryIssueCreateDeclaresParticipation's
// negative twin, and pins R2.3: an ordinary write never promotes a legacy
// record. The same no-history issues-table row, created while the flag was
// OFF, is legacy. Only a create-shaped call stamps a flagged row, so once the
// flag is on, an update-shaped mutation must leave participation_generation
// NULL and mint nothing. So must the bd update --persistent repair that then
// clears the flag in place: that repair is update-shaped too (a same-plane
// normalize), so the row it leaves is an ordinary legacy row, still fenced.
func RunParticipationGenerationLegacyNoHistoryIssueStaysLegacy(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
if err := fixture.SetFlag(ctx, false); err != nil {
t.Fatalf("disabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-no-history-legacy"
if err := fixture.CreateNoHistoryIssue(ctx, id); err != nil {
t.Fatalf("creating no-history issues-plane row %s with the flag off: %v", id, err)
}
if gen, err := fixture.ParticipationGeneration(ctx, id); err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
} else if gen != nil {
t.Fatalf("participation_generation for %s = %d before the flag was ever turned on, want NULL — "+
"this case cannot test that a legacy no-history row stays legacy against a row that was never "+
"legacy", id, *gen)
}
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
beforeRevision, err := fixture.CurrentRevision(ctx, id)
if err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
}
assertStillLegacy := func(after string) {
t.Helper()
if gen, err := fixture.ParticipationGeneration(ctx, id); err != nil {
t.Fatalf("reading participation_generation for %s: %v", id, err)
} else if gen != nil {
t.Errorf("participation_generation for %s = %d after %s with the flag on, want NULL: the row "+
"was created with the flag off, and an update-shaped write must not promote a legacy "+
"record (R2.3), whatever its no-history flag says", id, *gen, after)
}
if count, err := fixture.VersionRowCount(ctx, id); err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
} else if count != 0 {
t.Errorf("version row count for %s = %d after %s with the flag on, want 0: a legacy row's "+
"update-shaped mint is fenced (design §16.2b)", id, count, after)
}
if revision, err := fixture.CurrentRevision(ctx, id); err != nil {
t.Fatalf("reading current_revision for %s: %v", id, err)
} else if revision != beforeRevision {
t.Errorf("current_revision for %s went from %d to %d after %s, want unchanged: a fenced "+
"mint runs neither half of the seam's write", id, beforeRevision, revision, after)
}
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
assertStillLegacy("an update-shaped mutation")
if err := fixture.MovePersistent(ctx, id); err != nil {
t.Fatalf("repairing %s to persistent: %v", id, err)
}
assertStillLegacy("the persistent repair")
}
// RunParticipationGenerationFenceIgnoresSchemaSkewHatch pins design §16.2(c):
// BD_IGNORE_SCHEMA_SKEW=1 downgrades CheckForwardDrift's refusal to a warning
// (internal/storage/schema/schema.go), but it must have no effect on this
// fence — the fence keys on the participation_generation column's real data,
// not on the migration cursor the hatch is about, so a write admitted through
// that hatch is still, correctly, skipped when the record is legacy.
func RunParticipationGenerationFenceIgnoresSchemaSkewHatch(t *testing.T, ctx context.Context, fixture ParticipationGenerationFixture) {
t.Helper()
t.Setenv("BD_IGNORE_SCHEMA_SKEW", "1")
if err := fixture.SetFlag(ctx, false); err != nil {
t.Fatalf("disabling versioned history: %v", err)
}
id := fixture.IssuePrefix + "-schema-skew-hatch"
if err := fixture.Mutate(ctx, id); err != nil {
t.Fatalf("mutating %s: %v", id, err)
}
if err := fixture.SetFlag(ctx, true); err != nil {
t.Fatalf("enabling versioned history: %v", err)
}
beforeCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if err := fixture.MutateExisting(ctx, id); err != nil {
t.Fatalf("mutating existing %s: %v", id, err)
}
afterCount, err := fixture.VersionRowCount(ctx, id)
if err != nil {
t.Fatalf("counting version rows for %s: %v", id, err)
}
if afterCount != beforeCount {
t.Errorf("version row count for %s went from %d to %d with BD_IGNORE_SCHEMA_SKEW=1 set, want "+
"unchanged: the schema-skew hatch must not bypass the participation_generation fence — they "+
"key on different planes (migration cursor vs. real column data) — so a write admitted "+
"through the hatch against a legacy record must still be skipped", id, beforeCount, afterCount)
}
}

View file

@ -1,837 +0,0 @@
package conformance
import (
"context"
"errors"
"strings"
"testing"
"time"
storeops "github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/types"
publicops "github.com/steveyegge/beads/issueops"
)
// This file holds the contract every implementation of publicops.Heartbeater
// must satisfy. Each case asserts what issueops/heartbeater.go PROMISES, cited
// by symbol.
//
// THREE LEGS, ONE BODY. dolt, embedded dolt and the unit-of-work provider all
// reach internal/storage/issueops.ExecuteHeartbeatInTx, so a per-leg failure
// here is a wrapper's failure: a commit the leg added, a hook it fired, a
// refusal that stopped matching errors.Is.
//
// THE QUIET CASE IS THE POINT. A heartbeat is the hottest write in a fleet and
// it is cheap because it writes the lease row and nothing else. Most of what
// RunHeartbeaterChangesNothingOnTheRow asserts is an ABSENCE — no revision, no
// version, no updated_at, no event, no journal entry, no history entry, no
// hook — and each absence is something a plausible wrapper would add.
//
// THE LIVE-CLAIM FENCE IS AN INVARIANT AND A PREDICATE. The RefusesAfter*
// cases hold the invariant: each ends a claim one way and asserts both that
// the lease row is gone and that the holder's next heartbeat is refused. The
// RefusesAnOrphanedLease* cases hold the predicate: a lease row that survives
// on an issue that is no longer claimed by its holder (what a re-arm racing a
// release or close can leave on Dolt) is refused AND deleted, never refreshed.
type HeartbeaterFixture struct {
// IssuePrefix namespaces the ids each assertion seeds, so several of them
// can share one database.
IssuePrefix string
// Heartbeater is the surface under test.
Heartbeater publicops.Heartbeater
// CreateIssue seeds a durable issue in the issues plane.
CreateIssue func(context.Context, *types.Issue, string) error
// CreateWisp seeds an ephemeral issue in the wisps plane. A nil CreateWisp
// SKIPS the wisp case loudly.
CreateWisp func(context.Context, *types.Issue, string) error
// Claimer takes the claim, and with it the lease row, a heartbeat
// refreshes.
Claimer publicops.Claimer
// Lifecycle ends or moves a claim (close, a status move, a hand-doled
// claim) and performs the guarded write the revision case lands.
Lifecycle publicops.Lifecycle
// Releaser gives a claim up for the release case. Nil SKIPS that case.
Releaser publicops.Releaser
// LeaseReclaimer reverts an aged claim for the reclaim case. Nil, or a nil
// Exec, SKIPS that case.
LeaseReclaimer publicops.LeaseReclaimer
// Exec runs raw statements against the backing database: the cases use it
// to age a lease.
Exec func(ctx context.Context, statements []SQLStatement) error
// ExecUncommitted runs raw statements as ANOTHER writer that leaves its
// change uncommitted in the version-controlled working set (a batch-mode
// edit): SQL-committed, no version-control commit. Nil means Exec already
// behaves so.
ExecUncommitted func(ctx context.Context, statements []SQLStatement) error
// QueryScalar runs a single-row query and scans it, so the post-state is
// read RAW rather than through the role being tested.
QueryScalar func(context.Context, string, []any, ...any) error
// CountHistory reports how many version-control entries the fixture's
// branch has. Nil SKIPS that one assertion, loudly, in the quiet case.
CountHistory func(context.Context) (int, error)
// SetJournalEnabled turns on durable journaling, so the quiet case can
// observe that a heartbeat records nothing in bd_events_journal. Nil SKIPS
// that one assertion, loudly.
SetJournalEnabled func(enabled bool)
// SetVersionedHistoryEnabled turns on dual-write issue-version history, so
// the quiet case can observe that a heartbeat records no issue_versions
// row. Nil SKIPS that one assertion, loudly.
SetVersionedHistoryEnabled func(enabled bool)
// HookedHeartbeater is the same role taken off the leg's HOOK-FIRING chain
// (storage.HookFiringStore on the store legs, uow.NewNotifyingProvider on
// the unit-of-work leg), built over the runner FiredUpdates reads. Nil,
// with FiredUpdates, SKIPS the no-hook assertion loudly.
HookedHeartbeater publicops.Heartbeater
// FiredUpdates reports, in firing order, the issue id of every on_update
// the hooked chain ran so far.
FiredUpdates func(context.Context) ([]string, error)
}
const (
heartbeaterHolder = "hb-holder"
heartbeaterIntruder = "hb-intruder"
heartbeaterReaper = "hb-reaper"
)
// RunHeartbeaterRefreshesTheHoldersLease pins the refresh itself
// (Heartbeater: "pushes the lease the caller holds forward by the store's
// TTL") and every member of the HeartbeatResult, against the row READ RAW.
func RunHeartbeaterRefreshesTheHoldersLease(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
id := fixture.IssuePrefix + "-refresh"
heartbeaterSeedClaimed(t, ctx, fixture, id)
aged := time.Now().UTC().Add(-time.Minute).Truncate(time.Second)
if err := fixture.Exec(ctx, []SQLStatement{{
Query: "UPDATE leases SET lease_expires_at = ?, heartbeat_at = ? WHERE issue_id = ?",
Args: []any{aged, aged, id},
}}); err != nil {
t.Fatalf("age the lease on %s: %v", id, err)
}
before := time.Now().UTC().Add(-time.Second)
result := heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
after := time.Now().UTC().Add(time.Second)
if result.IssueID != id || result.Holder != heartbeaterHolder || result.Rearmed {
t.Fatalf("result = %+v, want {IssueID:%s Holder:%s Rearmed:false}", result, id, heartbeaterHolder)
}
if result.HeartbeatAt.Before(before) || result.HeartbeatAt.After(after) {
t.Fatalf("HeartbeatAt = %v, want the server clock at the call (between %v and %v)", result.HeartbeatAt, before, after)
}
if ttl := result.LeaseExpiresAt.Sub(result.HeartbeatAt); heartbeaterAbs(ttl-storeops.DefaultLeaseTTL) > time.Second {
t.Fatalf("LeaseExpiresAt - HeartbeatAt = %v, want the store's lease TTL %v", ttl, storeops.DefaultLeaseTTL)
}
if moved := heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM leases WHERE issue_id = ? AND holder = ? AND lease_expires_at > ? AND heartbeat_at > ?",
id, heartbeaterHolder, aged, aged); moved != 1 {
t.Fatal("the lease row's lease_expires_at and heartbeat_at did not move forward")
}
heartbeaterRequireStoredMatches(t, ctx, fixture, id, result, before, after)
}
// RunHeartbeaterASameSecondHeartbeatIsNotARearm pins HeartbeatResult.Rearmed
// against the refresh that changes no value: a heartbeat landing in the same
// second as the claim or the previous heartbeat writes values identical to the
// row's (the lease columns hold whole seconds), which some engines report as
// zero rows affected. It is still a refresh of the caller's own row: Rearmed
// is false, and the lease's granted_at and granted_node do not move.
func RunHeartbeaterASameSecondHeartbeatIsNotARearm(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
for i := 0; i < 3; i++ {
id := fixture.IssuePrefix + "-samesec-" + string(rune('a'+i))
heartbeaterSeedClaimed(t, ctx, fixture, id)
granted := heartbeaterScalar[string](t, ctx, fixture,
"SELECT CONCAT(CAST(granted_at AS CHAR), '|', COALESCE(granted_node, '')) FROM leases WHERE issue_id = ?", id)
for beat := 0; beat < 2; beat++ {
result := heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
if result.Rearmed {
t.Fatalf("heartbeat %d on %s right after the claim = %+v, want Rearmed:false: the holder's lease row existed", beat+1, id, result)
}
}
if got := heartbeaterScalar[string](t, ctx, fixture,
"SELECT CONCAT(CAST(granted_at AS CHAR), '|', COALESCE(granted_node, '')) FROM leases WHERE issue_id = ?", id); got != granted {
t.Fatalf("granted_at|granted_node on %s moved from %s to %s across refreshes; a refresh never re-grants", id, granted, got)
}
}
}
// RunHeartbeaterChangesNothingOnTheRow pins the role's quiet promise
// (Heartbeater: "A REFRESH WRITES ONLY THE LEASE ROW"): the issue row's revision
// (row_lock), its current_revision, its updated_at, its events, the events
// journal, issue_versions, the version-control history and the hooks are all
// exactly where the claim left them.
func RunHeartbeaterChangesNothingOnTheRow(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
if fixture.SetJournalEnabled != nil {
fixture.SetJournalEnabled(true)
defer fixture.SetJournalEnabled(false)
} else {
t.Log("HeartbeaterFixture.SetJournalEnabled is nil: the journal assertion is skipped on this backend")
}
if fixture.SetVersionedHistoryEnabled != nil {
fixture.SetVersionedHistoryEnabled(true)
defer fixture.SetVersionedHistoryEnabled(false)
} else {
t.Log("HeartbeaterFixture.SetVersionedHistoryEnabled is nil: the issue_versions assertion is skipped on this backend")
}
id := fixture.IssuePrefix + "-quiet"
heartbeaterSeedClaimed(t, ctx, fixture, id)
// updated_at is stored at second precision on some backends; step past
// the claim's second so a stamp the heartbeat added cannot hide in it.
time.Sleep(1100 * time.Millisecond)
snapshot := func() heartbeaterRowSnapshot {
return heartbeaterSnapshot(t, ctx, fixture, id)
}
before := snapshot()
fired := heartbeaterFired(t, ctx, fixture, id)
surface := fixture.Heartbeater
if fixture.HookedHeartbeater != nil && fixture.FiredUpdates != nil {
surface = fixture.HookedHeartbeater
} else {
t.Log("HeartbeaterFixture.HookedHeartbeater/FiredUpdates is nil: the no-hook assertion is skipped on this backend")
}
heartbeat(t, ctx, surface, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
after := snapshot()
if before != after {
t.Fatalf("a heartbeat changed the issue's durable state:\nbefore %+v\nafter %+v", before, after)
}
if got := heartbeaterFired(t, ctx, fixture, id); got != fired {
t.Fatalf("on_update fired %d time(s) for %s across a refresh, want 0: a refresh fires no hook", got-fired, id)
}
}
// RunHeartbeaterAGuardedWriteWithThePreHeartbeatRevisionStillWins is the
// reason the quiet case matters to a caller: the holder's revision token
// survives its own heartbeats, so a guarded write it composed from the claim
// still lands.
func RunHeartbeaterAGuardedWriteWithThePreHeartbeatRevisionStillWins(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.Lifecycle is nil: this backend cannot land a guarded write")
}
id := fixture.IssuePrefix + "-guarded"
revision := heartbeaterSeedClaimed(t, ctx, fixture, id)
heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
if _, err := fixture.Lifecycle.Update(ctx, publicops.UpdateRequest{
Actor: heartbeaterHolder, IssueID: id, ExpectedVersion: &revision,
Patch: publicops.IssuePatch{Notes: publicops.Field[string]{Set: true, Value: "after two heartbeats"}},
}); err != nil {
t.Fatalf("guarded write with the claim's revision after heartbeats = %v, want it to land", err)
}
}
// RunHeartbeaterRefusesAForeignHolder pins the fence (Heartbeater REFUSALS:
// "an issue another actor holds: a *LeaseConflictError naming the Holder,
// wrapping ErrAlreadyClaimed"), and that the refusal writes nothing.
func RunHeartbeaterRefusesAForeignHolder(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
id := fixture.IssuePrefix + "-foreign"
heartbeaterSeedClaimed(t, ctx, fixture, id)
// Age the holder's lease first, so a heartbeat that ignored the holder
// fence would really CHANGE the row (some engines count only changed rows,
// and the columns hold whole seconds: an unaged row refreshed in the
// claim's second changes nothing and would hide the missing fence).
aged := time.Now().UTC().Add(-time.Minute).Truncate(time.Second)
if err := fixture.Exec(ctx, []SQLStatement{{
Query: "UPDATE leases SET lease_expires_at = ?, heartbeat_at = ? WHERE issue_id = ?",
Args: []any{aged, aged, id},
}}); err != nil {
t.Fatalf("age the lease on %s: %v", id, err)
}
lease := heartbeaterScalar[string](t, ctx, fixture, "SELECT CONCAT(CAST(lease_expires_at AS CHAR), '|', CAST(heartbeat_at AS CHAR), '|', holder) FROM leases WHERE issue_id = ?", id)
_, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterIntruder, IssueID: id})
if !errors.Is(err, publicops.ErrAlreadyClaimed) {
t.Fatalf("heartbeat by a non-holder = %v, want ErrAlreadyClaimed", err)
}
if errors.Is(err, publicops.ErrLeaseNotHeld) {
t.Fatalf("heartbeat by a non-holder = %v also matches ErrLeaseNotHeld; the two refusals must stay distinct", err)
}
conflict := heartbeaterConflict(t, err)
if conflict.IssueID != id || conflict.Holder != heartbeaterHolder || conflict.Status != types.StatusInProgress {
t.Fatalf("LeaseConflictError = %+v, want {IssueID:%s Holder:%s Status:%s}", conflict, id, heartbeaterHolder, types.StatusInProgress)
}
if got := heartbeaterScalar[string](t, ctx, fixture, "SELECT CONCAT(CAST(lease_expires_at AS CHAR), '|', CAST(heartbeat_at AS CHAR), '|', holder) FROM leases WHERE issue_id = ?", id); got != lease {
t.Fatalf("a refused heartbeat moved the holder's lease from %s to %s", lease, got)
}
}
// RunHeartbeaterCommitsOnlyItsOwnTables pins the commit discipline against a
// DIRTY working set (Heartbeater: "A REFRESH WRITES ONLY THE LEASE ROW"; "A
// RE-ARM IS RECORDED AS A MUTATION"): another writer has left an uncommitted
// versioned change (a batch-mode edit, here a config row). A refresh and a
// refusal make no version-control commit and leave that change uncommitted;
// a re-arm makes exactly one commit, of its own tables, and still leaves the
// other writer's change uncommitted rather than sweeping it in under the
// heartbeat's message.
func RunHeartbeaterCommitsOnlyItsOwnTables(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
if fixture.CountHistory == nil || fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.CountHistory/Lifecycle is nil: this backend has no version-control history to observe")
}
refreshed := fixture.IssuePrefix + "-dirty-refresh"
heartbeaterSeedClaimed(t, ctx, fixture, refreshed)
refused := fixture.IssuePrefix + "-dirty-refused"
heartbeaterSeed(t, ctx, fixture, refused)
rearmed := fixture.IssuePrefix + "-dirty-rearm"
heartbeaterSeed(t, ctx, fixture, rearmed)
if _, err := fixture.Lifecycle.Update(ctx, publicops.UpdateRequest{
Actor: heartbeaterHolder, IssueID: rearmed,
Patch: publicops.IssuePatch{
Status: publicops.Field[publicops.Status]{Set: true, Value: types.StatusInProgress},
Assignee: publicops.Field[string]{Set: true, Value: heartbeaterHolder},
},
}); err != nil {
t.Fatalf("hand-dole %s: %v", rearmed, err)
}
probe := "heartbeat.dirty-probe." + fixture.IssuePrefix
dirty := fixture.Exec
if fixture.ExecUncommitted != nil {
dirty = fixture.ExecUncommitted
}
if err := dirty(ctx, []SQLStatement{{
Query: "REPLACE INTO config (`key`, value) VALUES (?, ?)", Args: []any{probe, "uncommitted"},
}}); err != nil {
t.Fatalf("dirty the working set: %v", err)
}
defer func() {
_ = dirty(ctx, []SQLStatement{{Query: "DELETE FROM config WHERE `key` = ?", Args: []any{probe}}})
}()
foreignDirty := func(when string) {
t.Helper()
if n := heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM dolt_status WHERE table_name = 'config'"); n == 0 {
t.Fatalf("%s: the other writer's uncommitted config change was committed; a heartbeat commits only its own tables", when)
}
}
history := func() int {
t.Helper()
n, err := fixture.CountHistory(ctx)
if err != nil {
t.Fatalf("CountHistory: %v", err)
}
return n
}
foreignDirty("before any heartbeat")
before := history()
heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: refreshed})
if got := history(); got != before {
t.Fatalf("a refresh moved the version-control history %d -> %d; a refresh makes no commit", before, got)
}
foreignDirty("after a refresh")
if _, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: refused}); err == nil {
t.Fatalf("heartbeat on unclaimed %s succeeded, want a refusal", refused)
}
if got := history(); got != before {
t.Fatalf("a refusal moved the version-control history %d -> %d; a refusal makes no commit", before, got)
}
foreignDirty("after a refusal")
if result := heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: rearmed}); !result.Rearmed {
t.Fatalf("heartbeat on hand-doled %s = %+v, want Rearmed", rearmed, result)
}
if got := history(); got != before+1 {
t.Fatalf("a re-arm moved the version-control history %d -> %d, want exactly one commit", before, got)
}
foreignDirty("after a re-arm")
}
// RunHeartbeaterRefusesAnOrphanedLeaseOnAReleasedIssue and
// ...OnAClosedIssue and ...OnAnIssueSomeoneElseHolds pin the live-claim
// predicate (Heartbeater: "THE LIVE-CLAIM FENCE IS A PREDICATE"): a lease row
// that names the caller but survives on an issue that is open, closed, or
// in_progress under another assignee is refused, never refreshed, and the
// refusal deletes it (Heartbeater: the one write a refusal makes). The row
// is planted raw: it is the state a re-arm racing a release or close leaves.
func RunHeartbeaterRefusesAnOrphanedLeaseOnAReleasedIssue(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
id := fixture.IssuePrefix + "-orphan-open"
heartbeaterSeed(t, ctx, fixture, id)
heartbeaterRefusesAnOrphan(t, ctx, fixture, id, types.StatusOpen, "")
}
func RunHeartbeaterRefusesAnOrphanedLeaseOnAClosedIssue(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
if fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.Lifecycle is nil: this backend cannot close the claim")
}
id := fixture.IssuePrefix + "-orphan-closed"
heartbeaterSeedClaimed(t, ctx, fixture, id)
if _, err := fixture.Lifecycle.Close(ctx, publicops.CloseRequest{Actor: heartbeaterHolder, IssueID: id, Reason: "done"}); err != nil {
t.Fatalf("close %s: %v", id, err)
}
heartbeaterRefusesAnOrphan(t, ctx, fixture, id, types.StatusClosed, "")
}
func RunHeartbeaterRefusesAnOrphanedLeaseOnAnIssueSomeoneElseHolds(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
requireHeartbeaterExec(t, fixture)
if fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.Lifecycle is nil: this backend cannot hand-dole a claim")
}
id := fixture.IssuePrefix + "-orphan-moved"
heartbeaterSeed(t, ctx, fixture, id)
if _, err := fixture.Lifecycle.Update(ctx, publicops.UpdateRequest{
Actor: heartbeaterIntruder, IssueID: id,
Patch: publicops.IssuePatch{
Status: publicops.Field[publicops.Status]{Set: true, Value: types.StatusInProgress},
Assignee: publicops.Field[string]{Set: true, Value: heartbeaterIntruder},
},
}); err != nil {
t.Fatalf("hand-dole %s to %s: %v", id, heartbeaterIntruder, err)
}
heartbeaterRefusesAnOrphan(t, ctx, fixture, id, types.StatusInProgress, heartbeaterIntruder)
}
// heartbeaterRefusesAnOrphan plants a lease row for heartbeaterHolder on id
// (which the holder does not hold), heartbeats as the holder, and asserts the
// refusal and that the row is gone.
func heartbeaterRefusesAnOrphan(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string, status types.Status, foreign string) {
t.Helper()
now := time.Now().UTC().Truncate(time.Second)
if err := fixture.Exec(ctx, []SQLStatement{
{Query: "DELETE FROM leases WHERE issue_id = ?", Args: []any{id}},
{
Query: "INSERT INTO leases (issue_id, holder, granted_at, lease_expires_at, heartbeat_at, granted_node) VALUES (?, ?, ?, ?, ?, '')",
Args: []any{id, heartbeaterHolder, now.Add(-time.Minute), now.Add(time.Hour), now.Add(-time.Minute)},
},
}); err != nil {
t.Fatalf("plant an orphaned lease on %s: %v", id, err)
}
_, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
conflict := heartbeaterConflict(t, err)
if foreign != "" {
if !errors.Is(err, publicops.ErrAlreadyClaimed) || conflict.Holder != foreign {
t.Fatalf("heartbeat over an orphaned lease on an issue %s holds = %v (%+v), want ErrAlreadyClaimed naming %s", foreign, err, conflict, foreign)
}
} else if !errors.Is(err, publicops.ErrLeaseNotHeld) || conflict.Holder != "" {
t.Fatalf("heartbeat over an orphaned lease on a %s issue = %v (%+v), want ErrLeaseNotHeld", status, err, conflict)
}
if conflict.IssueID != id || conflict.Status != status || conflict.Ephemeral {
t.Fatalf("LeaseConflictError = %+v, want {IssueID:%s Status:%s Ephemeral:false}", conflict, id, status)
}
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 0 {
t.Fatalf("lease rows on %s after the refusal = %d, want 0: a refusal deletes the caller's orphaned lease", id, n)
}
// And it stays refused: the next heartbeat finds no row to refresh.
if _, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id}); err == nil {
t.Fatalf("a second heartbeat on %s succeeded after the orphan was refused", id)
}
}
// heartbeaterRequireStoredMatches pins the reported times to the stored row
// (LeaseRenewal: "exactly what the lease row now holds"): lease_expires_at and
// heartbeat_at as stored are the result's, within the columns' one-second
// precision, and the stored expiry is the call's clock plus the store's TTL.
func heartbeaterRequireStoredMatches(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string, result publicops.HeartbeatResult, before, after time.Time) {
t.Helper()
window := func(at time.Time) (time.Time, time.Time) { return at.Add(-time.Second), at.Add(time.Second) }
hbLo, hbHi := window(result.HeartbeatAt)
exLo, exHi := window(result.LeaseExpiresAt)
if n := heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM leases WHERE issue_id = ? AND holder = ? AND heartbeat_at BETWEEN ? AND ? AND lease_expires_at BETWEEN ? AND ?",
id, result.Holder, hbLo, hbHi, exLo, exHi); n != 1 {
t.Fatalf("the stored lease row on %s does not hold the reported heartbeat_at %v and lease_expires_at %v (within 1s)",
id, result.HeartbeatAt, result.LeaseExpiresAt)
}
ttlLo, ttlHi := before.Add(storeops.DefaultLeaseTTL), after.Add(storeops.DefaultLeaseTTL)
if n := heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM leases WHERE issue_id = ? AND lease_expires_at BETWEEN ? AND ?",
id, ttlLo, ttlHi); n != 1 {
t.Fatalf("the stored lease_expires_at on %s is not the call's clock plus the lease TTL %v", id, storeops.DefaultLeaseTTL)
}
if !result.HeartbeatAt.Equal(result.HeartbeatAt.Truncate(time.Second)) || !result.LeaseExpiresAt.Equal(result.LeaseExpiresAt.Truncate(time.Second)) {
t.Fatalf("result times %v / %v carry sub-second digits the lease columns cannot hold", result.HeartbeatAt, result.LeaseExpiresAt)
}
}
// RunHeartbeaterRefusesAfterClose, ...AfterRelease, ...AfterReclaim and
// ...AfterStatusMovedOffInProgress pin the in_progress fence through the
// lease-row invariant (Heartbeater: "a lease row exists only while its issue
// is in_progress with that holder as assignee"): each ends the claim one way,
// asserts the lease row went with it, and that the former holder's heartbeat
// is refused with ErrLeaseNotHeld, which also matches ErrNotClaimable.
func RunHeartbeaterRefusesAfterClose(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.Lifecycle is nil: this backend cannot close the claim")
}
heartbeaterRefusesAfter(t, ctx, fixture, "closed", types.StatusClosed, func(id string) error {
_, err := fixture.Lifecycle.Close(ctx, publicops.CloseRequest{Actor: heartbeaterHolder, IssueID: id, Reason: "done"})
return err
})
}
func RunHeartbeaterRefusesAfterRelease(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Releaser == nil {
t.Skip("HeartbeaterFixture.Releaser is nil: this backend cannot release the claim")
}
heartbeaterRefusesAfter(t, ctx, fixture, "released", types.StatusOpen, func(id string) error {
_, err := fixture.Releaser.Release(ctx, publicops.ReleaseRequest{Actor: heartbeaterHolder, IssueID: id})
return err
})
}
func RunHeartbeaterRefusesAfterReclaim(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.LeaseReclaimer == nil || fixture.Exec == nil {
t.Skip("HeartbeaterFixture.LeaseReclaimer/Exec is nil: this backend cannot reclaim the claim")
}
heartbeaterRefusesAfter(t, ctx, fixture, "reclaimed", types.StatusOpen, func(id string) error {
if err := fixture.Exec(ctx, []SQLStatement{{
Query: "UPDATE leases SET lease_expires_at = ? WHERE issue_id = ?",
Args: []any{time.Now().UTC().Add(-time.Hour), id},
}}); err != nil {
return err
}
result, err := fixture.LeaseReclaimer.Reclaim(ctx, publicops.ReclaimRequest{
Actor: heartbeaterReaper, Filter: publicops.ReclaimFilter{IDs: []string{id}},
})
if err == nil && len(result.Reclaimed) != 1 {
t.Fatalf("Reclaimed = %+v, want exactly %s", result.Reclaimed, id)
}
return err
})
}
func RunHeartbeaterRefusesAfterStatusMovedOffInProgress(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Lifecycle == nil {
t.Skip("HeartbeaterFixture.Lifecycle is nil: this backend cannot move the status")
}
heartbeaterRefusesAfter(t, ctx, fixture, "blocked", types.StatusBlocked, func(id string) error {
_, err := fixture.Lifecycle.Update(ctx, publicops.UpdateRequest{
Actor: heartbeaterHolder, IssueID: id,
Patch: publicops.IssuePatch{Status: publicops.Field[publicops.Status]{Set: true, Value: types.StatusBlocked}},
})
return err
})
}
// RunHeartbeaterRefusesAWisp pins the plane rule (Heartbeater REFUSALS: "a
// wisp ... ErrLeaseNotHeld"): wisps are never leased, so even a wisp the
// caller holds in_progress is refused, and no lease row appears for it.
func RunHeartbeaterRefusesAWisp(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.CreateWisp == nil || fixture.QueryScalar == nil {
t.Skip("HeartbeaterFixture.CreateWisp/QueryScalar is nil: this backend cannot seed a wisp")
}
id := fixture.IssuePrefix + "-wisp"
if err := fixture.CreateWisp(ctx, &types.Issue{
ID: id, Title: id, Status: types.StatusInProgress, Assignee: heartbeaterHolder,
Priority: 2, IssueType: types.TypeTask, Ephemeral: true,
}, "seed"); err != nil {
t.Fatalf("seed wisp %s: %v", id, err)
}
_, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
if !errors.Is(err, publicops.ErrLeaseNotHeld) || !errors.Is(err, publicops.ErrNotClaimable) {
t.Fatalf("heartbeat on a wisp = %v, want ErrLeaseNotHeld matching ErrNotClaimable", err)
}
if !strings.Contains(err.Error(), "ephemeral") {
t.Fatalf("heartbeat on a wisp = %q, want the refusal to say the issue is ephemeral", err)
}
if conflict := heartbeaterConflict(t, err); conflict.IssueID != id || conflict.Holder != "" {
t.Fatalf("LeaseConflictError = %+v, want {IssueID:%s Holder:\"\"}", conflict, id)
}
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 0 {
t.Fatalf("lease rows for wisp %s = %d, want 0: wisps are never leased", id, n)
}
}
// RunHeartbeaterRearmsAHandDoledClaim pins the self-heal (HeartbeatResult.
// Rearmed): an issue put in_progress with the caller as assignee by a generic
// update holds no lease row, and the holder's heartbeat grants one rather than
// refusing. The re-arm is recorded as a mutation (Heartbeater: "A RE-ARM IS
// RECORDED AS A MUTATION"): it remints the revision, which is what makes it
// collide with a racing release or close, and records a lease_rearmed event;
// the refresh after it does neither.
func RunHeartbeaterRearmsAHandDoledClaim(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Lifecycle == nil || fixture.QueryScalar == nil {
t.Skip("HeartbeaterFixture.Lifecycle/QueryScalar is nil: this backend cannot hand-dole a claim")
}
id := fixture.IssuePrefix + "-doled"
heartbeaterSeed(t, ctx, fixture, id)
if _, err := fixture.Lifecycle.Update(ctx, publicops.UpdateRequest{
Actor: heartbeaterHolder, IssueID: id,
Patch: publicops.IssuePatch{
Status: publicops.Field[publicops.Status]{Set: true, Value: types.StatusInProgress},
Assignee: publicops.Field[string]{Set: true, Value: heartbeaterHolder},
},
}); err != nil {
t.Fatalf("hand-dole %s: %v", id, err)
}
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 0 {
t.Fatalf("lease rows after a generic update = %d, want 0: the case needs a claim with no lease", n)
}
revision := heartbeaterScalar[int64](t, ctx, fixture, "SELECT row_lock FROM issues WHERE id = ?", id)
before := time.Now().UTC().Add(-time.Second)
result := heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
after := time.Now().UTC().Add(time.Second)
if !result.Rearmed || result.Holder != heartbeaterHolder {
t.Fatalf("result = %+v, want Rearmed:true Holder:%s", result, heartbeaterHolder)
}
heartbeaterRequireStoredMatches(t, ctx, fixture, id, result, before, after)
if n := heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM leases WHERE issue_id = ? AND holder = ? AND lease_expires_at > ?",
id, heartbeaterHolder, time.Now().UTC()); n != 1 {
t.Fatal("the re-armed heartbeat left no live lease row for the holder")
}
rearmed := heartbeaterScalar[int64](t, ctx, fixture, "SELECT row_lock FROM issues WHERE id = ?", id)
if rearmed == revision {
t.Fatalf("row_lock stayed %d across a re-arming heartbeat; a re-arm remints it so a racing release or close collides with it", revision)
}
rearmEvents := func() int {
return heartbeaterScalar[int](t, ctx, fixture,
"SELECT COUNT(*) FROM events WHERE issue_id = ? AND event_type = ?", id, string(types.EventLeaseRearmed))
}
if n := rearmEvents(); n != 1 {
t.Fatalf("lease_rearmed events on %s after a re-arm = %d, want 1: a re-arm is recorded as a mutation", id, n)
}
// The next heartbeat refreshes the lease it just granted: no re-arm, and
// no revision change.
if again := heartbeat(t, ctx, fixture.Heartbeater, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id}); again.Rearmed {
t.Fatalf("second heartbeat after the re-arm = %+v, want Rearmed:false", again)
}
if got := heartbeaterScalar[int64](t, ctx, fixture, "SELECT row_lock FROM issues WHERE id = ?", id); got != rearmed {
t.Fatalf("row_lock moved from %d to %d across a refresh after the re-arm", rearmed, got)
}
if n := rearmEvents(); n != 1 {
t.Fatalf("lease_rearmed events on %s after a refresh = %d, want still 1: a refresh records nothing", id, n)
}
}
// RunHeartbeaterAnswersNotFoundForAnAbsentID pins Heartbeater REFUSALS: "an
// IssueID that names no row on either plane: ErrNotFound".
func RunHeartbeaterAnswersNotFoundForAnAbsentID(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
_, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{
Actor: heartbeaterHolder, IssueID: fixture.IssuePrefix + "-absent",
})
if !errors.Is(err, publicops.ErrNotFound) {
t.Fatalf("heartbeat on an absent id = %v, want ErrNotFound", err)
}
}
// RunHeartbeaterRefusesABlankOrOverLongActor pins the request rules
// (HeartbeatRequest.Actor, Heartbeater REFUSALS): each is a
// *HeartbeatFieldError naming its field, matching ErrValidation.
func RunHeartbeaterRefusesABlankOrOverLongActor(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
id := fixture.IssuePrefix + "-refusals"
for _, test := range []struct {
name string
request publicops.HeartbeatRequest
field string
}{
{"an empty actor", publicops.HeartbeatRequest{IssueID: id}, publicops.HeartbeatFieldActor},
{"a blank actor", publicops.HeartbeatRequest{Actor: " \t", IssueID: id}, publicops.HeartbeatFieldActor},
{"an over-long actor", publicops.HeartbeatRequest{Actor: strings.Repeat("a", types.MaxFieldLen+1), IssueID: id}, publicops.HeartbeatFieldActor},
{"an empty id", publicops.HeartbeatRequest{Actor: heartbeaterHolder}, publicops.HeartbeatFieldIssueID},
} {
t.Run(test.name, func(t *testing.T) {
_, err := fixture.Heartbeater.Heartbeat(ctx, test.request)
if !errors.Is(err, publicops.ErrValidation) {
t.Fatalf("Heartbeat(%s) = %v, want ErrValidation", test.name, err)
}
var field *publicops.HeartbeatFieldError
if !errors.As(err, &field) || field.Field != test.field {
t.Fatalf("Heartbeat(%s) = %v, want a *HeartbeatFieldError naming %q", test.name, err, test.field)
}
})
}
}
// RunHeartbeaterDoesNotMutateTheRequest pins the role's "never mutate
// caller-owned request values".
func RunHeartbeaterDoesNotMutateTheRequest(t *testing.T, ctx context.Context, fixture HeartbeaterFixture) {
t.Helper()
id := fixture.IssuePrefix + "-nomutate"
heartbeaterSeedClaimed(t, ctx, fixture, id)
request := publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id}
want := request
heartbeat(t, ctx, fixture.Heartbeater, request)
if request != want {
t.Fatalf("request after Heartbeat = %+v, want %+v", request, want)
}
}
// heartbeaterRefusesAfter seeds and claims one issue, ends the claim with end,
// and asserts the invariant and the refusal.
func heartbeaterRefusesAfter(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, suffix string, status types.Status, end func(id string) error) {
t.Helper()
if fixture.QueryScalar == nil {
t.Skip("HeartbeaterFixture.QueryScalar is nil: this backend cannot read the lease row")
}
id := fixture.IssuePrefix + "-after-" + suffix
heartbeaterSeedClaimed(t, ctx, fixture, id)
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 1 {
t.Fatalf("lease rows for claimed %s = %d, want 1", id, n)
}
if err := end(id); err != nil {
t.Fatalf("end the claim on %s (%s): %v", id, suffix, err)
}
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 0 {
t.Fatalf("lease rows for %s %s = %d, want 0: the path that ended the claim left its lease row", suffix, id, n)
}
_, err := fixture.Heartbeater.Heartbeat(ctx, publicops.HeartbeatRequest{Actor: heartbeaterHolder, IssueID: id})
if !errors.Is(err, publicops.ErrLeaseNotHeld) || !errors.Is(err, publicops.ErrNotClaimable) {
t.Fatalf("heartbeat after the claim was %s = %v, want ErrLeaseNotHeld matching ErrNotClaimable", suffix, err)
}
if errors.Is(err, publicops.ErrAlreadyClaimed) {
t.Fatalf("heartbeat after the claim was %s = %v also matches ErrAlreadyClaimed", suffix, err)
}
conflict := heartbeaterConflict(t, err)
if conflict.IssueID != id || conflict.Holder != "" || conflict.Status != status {
t.Fatalf("LeaseConflictError = %+v, want {IssueID:%s Holder:\"\" Status:%s}", conflict, id, status)
}
if n := heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM leases WHERE issue_id = ?", id); n != 0 {
t.Fatalf("a refused heartbeat left %d lease row(s) for %s", n, id)
}
}
// heartbeaterRowSnapshot is every durable trace a heartbeat must not leave.
// A field the backend cannot observe holds -1.
type heartbeaterRowSnapshot struct {
RowLock int64
CurrentRevision int64
UpdatedAt string
Events int
JournalMaxSeq int64
IssueVersions int
History int
}
func heartbeaterSnapshot(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string) heartbeaterRowSnapshot {
t.Helper()
snap := heartbeaterRowSnapshot{
RowLock: heartbeaterScalar[int64](t, ctx, fixture, "SELECT row_lock FROM issues WHERE id = ?", id),
CurrentRevision: heartbeaterScalar[int64](t, ctx, fixture, "SELECT current_revision FROM issues WHERE id = ?", id),
UpdatedAt: heartbeaterScalar[string](t, ctx, fixture, "SELECT CAST(updated_at AS CHAR) FROM issues WHERE id = ?", id),
Events: heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM events WHERE issue_id = ?", id),
JournalMaxSeq: -1,
IssueVersions: -1,
History: -1,
}
if fixture.SetJournalEnabled != nil {
snap.JournalMaxSeq = heartbeaterScalar[int64](t, ctx, fixture, "SELECT COALESCE(MAX(seq), 0) FROM bd_events_journal")
}
if fixture.SetVersionedHistoryEnabled != nil {
snap.IssueVersions = heartbeaterScalar[int](t, ctx, fixture, "SELECT COUNT(*) FROM issue_versions WHERE issue_id = ?", id)
}
if fixture.CountHistory != nil {
n, err := fixture.CountHistory(ctx)
if err != nil {
t.Fatalf("CountHistory: %v", err)
}
snap.History = n
}
return snap
}
func heartbeaterFired(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string) int {
t.Helper()
if fixture.HookedHeartbeater == nil || fixture.FiredUpdates == nil {
return 0
}
ids, err := fixture.FiredUpdates(ctx)
if err != nil {
t.Fatalf("FiredUpdates: %v", err)
}
n := 0
for _, fired := range ids {
if fired == id {
n++
}
}
return n
}
func requireHeartbeaterExec(t *testing.T, fixture HeartbeaterFixture) {
t.Helper()
if fixture.Exec == nil || fixture.QueryScalar == nil {
t.Skip("HeartbeaterFixture.Exec/QueryScalar is nil: this backend cannot read or age a lease row")
}
}
func heartbeaterSeed(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string) {
t.Helper()
if err := fixture.CreateIssue(ctx, &types.Issue{
ID: id, Title: id, Status: types.StatusOpen, Priority: 2, IssueType: types.TypeTask,
}, "seed"); err != nil {
t.Fatalf("seed %s: %v", id, err)
}
}
// heartbeaterSeedClaimed creates id and claims it as heartbeaterHolder through
// the leg's Claimer, answering the claim's row version.
func heartbeaterSeedClaimed(t *testing.T, ctx context.Context, fixture HeartbeaterFixture, id string) int64 {
t.Helper()
if fixture.Claimer == nil {
t.Skip("HeartbeaterFixture.Claimer is nil: this backend cannot take the claim a heartbeat refreshes")
}
heartbeaterSeed(t, ctx, fixture, id)
claimed, err := fixture.Claimer.Claim(ctx, publicops.ClaimRequest{Actor: heartbeaterHolder, IssueID: id})
if err != nil {
t.Fatalf("claim %s as %s: %v", id, heartbeaterHolder, err)
}
if claimed.Issue == nil {
t.Fatalf("claim %s answered no issue", id)
}
return claimed.Issue.RowVersion
}
func heartbeat(t *testing.T, ctx context.Context, surface publicops.Heartbeater, request publicops.HeartbeatRequest) publicops.HeartbeatResult {
t.Helper()
result, err := surface.Heartbeat(ctx, request)
if err != nil {
t.Fatalf("Heartbeat(%+v): %v", request, err)
}
return result
}
func heartbeaterConflict(t *testing.T, err error) *publicops.LeaseConflictError {
t.Helper()
var conflict *publicops.LeaseConflictError
if !errors.As(err, &conflict) {
t.Fatalf("refusal %v (%T) is not a *LeaseConflictError", err, err)
}
return conflict
}
func heartbeaterScalar[T any](t *testing.T, ctx context.Context, fixture HeartbeaterFixture, query string, args ...any) T {
t.Helper()
var value T
if err := fixture.QueryScalar(ctx, query, args, &value); err != nil {
t.Fatalf("%s %v: %v", query, args, err)
}
return value
}
func heartbeaterAbs(d time.Duration) time.Duration {
if d < 0 {
return -d
}
return d
}

View file

@ -3175,335 +3175,6 @@ func assertReaderBriefRow(t *testing.T, what string, brief, full *types.Issue) {
}
}
// RunReaderListTimeBoundsAreStrictAndWholeSecond pins the eight time bounds
// ListRequest carries beside the created pair — UpdatedAfter/Before,
// ClosedAfter/Before, DeferAfter/Before and DueAfter/Before — at their exact
// boundaries (reader.go: each is a strict bound on its column).
//
// THE BOUNDARY IS THE ASSERTION. Three rows sit one second apart around an
// instant T, so a body that compared inclusively, swapped the two ends, or
// bound the wrong column fails on a row rather than on nothing:
//
// - after=T selects exactly the T+1s row and before=T exactly the T-1s row,
// so the row AT T is excluded by both;
// - a bound carrying a sub-second remainder (T+900ms) behaves as T on both
// ends, because the bound is compared at whole-second precision (the
// storage builder formats it as RFC 3339 without a fraction);
// - a row whose column is NULL — an open row's closed_at, an unset
// defer_until or due_at — never matches either bound;
// - a bound spelled in a non-UTC zone selects exactly what the same instant
// spelled in UTC does. An offset is part of the instant, not decoration,
// and a body that dropped it would move the bound by the offset.
//
// Every family scopes itself by id and seeds no labels, so no write after the
// insert can move updated_at off the instant it was seeded at; AllFlag keeps
// the closed rows in view.
func RunReaderListTimeBoundsAreStrictAndWholeSecond(t *testing.T, ctx context.Context, fixture ReaderFixture) {
t.Helper()
at := time.Now().UTC().Truncate(time.Second).Add(-3 * time.Hour)
created := at.Add(-time.Hour)
instants := []struct {
tag string
at time.Time
}{
{"early", at.Add(-time.Second)},
{"exact", at},
{"late", at.Add(time.Second)},
}
for _, family := range []struct {
name string
// set stamps the family's column onto a seed.
set func(issue *types.Issue, v time.Time)
// nullable seeds a fourth row with the column NULL.
nullable bool
after func(*publicops.ListRequest, *time.Time)
before func(*publicops.ListRequest, *time.Time)
}{
{
name: "updated",
set: func(issue *types.Issue, v time.Time) { issue.UpdatedAt = v },
after: func(r *publicops.ListRequest, v *time.Time) { r.UpdatedAfter = v },
before: func(r *publicops.ListRequest, v *time.Time) { r.UpdatedBefore = v },
},
{
name: "closed",
set: func(issue *types.Issue, v time.Time) {
issue.Status = types.StatusClosed
issue.UpdatedAt = v
issue.ClosedAt = &v
},
nullable: true,
after: func(r *publicops.ListRequest, v *time.Time) { r.ClosedAfter = v },
before: func(r *publicops.ListRequest, v *time.Time) { r.ClosedBefore = v },
},
{
name: "defer",
set: func(issue *types.Issue, v time.Time) { issue.DeferUntil = &v },
nullable: true,
after: func(r *publicops.ListRequest, v *time.Time) { r.DeferAfter = v },
before: func(r *publicops.ListRequest, v *time.Time) { r.DeferBefore = v },
},
{
name: "due",
set: func(issue *types.Issue, v time.Time) { issue.DueAt = &v },
nullable: true,
after: func(r *publicops.ListRequest, v *time.Time) { r.DueAfter = v },
before: func(r *publicops.ListRequest, v *time.Time) { r.DueBefore = v },
},
} {
caseTag := "ltb" + family.name
ids := map[string]string{}
var scope []string
for _, inst := range instants {
id := readerID(fixture, caseTag, inst.tag)
ids[inst.tag] = id
scope = append(scope, id)
issue := readerIssue(id, types.TypeTask, "")
issue.CreatedAt, issue.UpdatedAt = created, created
family.set(issue, inst.at)
seedReaderIssue(t, ctx, fixture, issue)
}
if family.nullable {
id := readerID(fixture, caseTag, "null")
scope = append(scope, id)
issue := readerIssue(id, types.TypeTask, "")
issue.CreatedAt, issue.UpdatedAt = created, created
seedReaderIssue(t, ctx, fixture, issue)
}
idScope := readerIDFilter(scope...)
list := func(what string, apply func(*publicops.ListRequest, *time.Time), bound time.Time) []string {
t.Helper()
req := publicops.ListRequest{IDFilter: idScope, AllFlag: true}
apply(&req, &bound)
page, err := fixture.Reader.List(ctx, req)
if err != nil {
t.Fatalf("List (%s %s): %v", family.name, what, err)
}
assertReaderPageNotNil(t, "List ("+family.name+" "+what+")", page)
got := readerPageIDs(page)
slices.Sort(got)
return got
}
expect := func(what string, apply func(*publicops.ListRequest, *time.Time), bound time.Time, want string) {
t.Helper()
if got := list(what, apply, bound); !slices.Equal(got, []string{want}) {
t.Errorf("List (%s %s %s) = %v, want exactly [%s]", family.name, what, bound.Format(time.RFC3339Nano), got, want)
}
}
plus2 := time.FixedZone("UTC+2", 2*60*60)
for _, bound := range []struct {
what string
v time.Time
}{
{"at T", at},
{"at T with a sub-second remainder", at.Add(900 * time.Millisecond)},
{"at T spelled in a +02:00 zone", at.In(plus2)},
} {
expect("after "+bound.what, family.after, bound.v, ids["late"])
expect("before "+bound.what, family.before, bound.v, ids["early"])
}
// The NULL row is outside even the widest bounds on both ends.
if family.nullable {
wide := at.Add(-24 * time.Hour)
if got, want := list("after a day earlier", family.after, wide), sortedCopy(ids["early"], ids["exact"], ids["late"]); !slices.Equal(got, want) {
t.Errorf("List (%s after a day earlier) = %v, want %v — a NULL column never matches", family.name, got, want)
}
if got, want := list("before a day later", family.before, at.Add(24*time.Hour)), sortedCopy(ids["early"], ids["exact"], ids["late"]); !slices.Equal(got, want) {
t.Errorf("List (%s before a day later) = %v, want %v — a NULL column never matches", family.name, got, want)
}
}
}
}
// RunReaderListFilterFamiliesNarrowToTheirRows pins one included and one
// excluded row for each remaining ListRequest filter family that `bd list`
// publishes beyond the scope filters: the priority trio, the three text
// substrings, the empty-description and no-labels predicates, the top-level
// predicate, the type exclusion, the spec prefix, the label pattern and
// regex, the external-ref pair, the pinned-flag pair, the deferred and
// overdue predicates, the status exclusion and the molecule type.
//
// Each row is scoped by id and every arm asks AllFlag (the pinned arms
// excepted, which are about that interplay), so an arm whose filter the body
// dropped answers its whole scope and fails, and one whose filter the body
// inverted answers the other row.
//
// PinnedFlag with NoPinnedFlag is a contradiction, and the role refuses it as
// a validation error rather than letting one of the two silently win.
// ParentID with NoParent is refused the same way, as CountRequest refuses it.
func RunReaderListFilterFamiliesNarrowToTheirRows(t *testing.T, ctx context.Context, fixture ReaderFixture) {
t.Helper()
id := func(name string) string { return readerID(fixture, "lff", name) }
seed := func(name string, mutate func(*types.Issue)) string {
t.Helper()
issue := readerIssue(id(name), types.TypeTask, "")
if mutate != nil {
mutate(issue)
}
seedReaderIssue(t, ctx, fixture, issue)
return issue.ID
}
intp := func(v int) *int { return &v }
past := time.Now().UTC().Truncate(time.Second).Add(-48 * time.Hour)
future := time.Now().UTC().Truncate(time.Second).Add(48 * time.Hour)
label := readerLabel(fixture, "lffpat")
external := fixture.IssuePrefix + "-LFF-ext-17"
spec := "docs/" + fixture.IssuePrefix + "-lff/"
p0 := seed("p0", func(i *types.Issue) { i.Priority = 0 })
p2 := seed("p2", func(i *types.Issue) { i.Priority = 2 })
p4 := seed("p4", func(i *types.Issue) { i.Priority = 4 })
textT := seed("text-t", func(i *types.Issue) { i.Title = "a title carrying ttok-lff" })
textD := seed("text-d", func(i *types.Issue) { i.Description = "a description carrying dtok-lff" })
textN := seed("text-n", func(i *types.Issue) { i.Notes = "notes carrying ntok-lff" })
labeled := seed("labeled", func(i *types.Issue) { i.Labels = []string{label} })
unlabeled := seed("unlabeled", nil)
parent := seed("parent", func(i *types.Issue) { i.IssueType = types.TypeEpic })
child := seed("child", nil)
if err := fixture.AddDependency(ctx, &types.Dependency{IssueID: child, DependsOnID: parent, Type: types.DepParentChild}, "seed"); err != nil {
t.Fatalf("seed edge %s -> %s: %v", child, parent, err)
}
loose := seed("loose", nil)
typeTask := seed("type-task", nil)
typeBug := seed("type-bug", func(i *types.Issue) { i.IssueType = types.TypeBug })
typeChore := seed("type-chore", func(i *types.Issue) { i.IssueType = types.TypeChore })
specced := seed("specced", func(i *types.Issue) { i.SpecID = spec + "design.md" })
unspecced := seed("unspecced", nil)
extRow := seed("ext", func(i *types.Issue) { i.ExternalRef = &external })
extOther := seed("ext-other", func(i *types.Issue) {
other := fixture.IssuePrefix + "-other-99"
i.ExternalRef = &other
})
pinned := seed("pinned", func(i *types.Issue) { i.Pinned = true })
unpinned := seed("unpinned", nil)
deferred := seed("deferred", func(i *types.Issue) { i.DeferUntil = &future })
undeferred := seed("undeferred", nil)
overdue := seed("overdue", func(i *types.Issue) { i.DueAt = &past })
dueLater := seed("due-later", func(i *types.Issue) { i.DueAt = &future })
closedOverdue := seed("closed-overdue", func(i *types.Issue) {
i.Status = types.StatusClosed
closedAt := time.Now().UTC().Truncate(time.Second).Add(-time.Hour)
i.ClosedAt = &closedAt
i.DueAt = &past
})
noDue := seed("no-due", nil)
swarm := seed("mol-swarm", func(i *types.Issue) { i.MolType = types.MolTypeSwarm })
patrol := seed("mol-patrol", func(i *types.Issue) { i.MolType = types.MolTypePatrol })
stOpen := seed("st-open", nil)
stProgress := seed("st-progress", func(i *types.Issue) { i.Status = types.StatusInProgress })
stBlocked := seed("st-blocked", func(i *types.Issue) { i.Status = types.StatusBlocked })
stClosed := seed("st-closed", func(i *types.Issue) {
i.Status = types.StatusClosed
closedAt := time.Now().UTC().Truncate(time.Second).Add(-time.Hour)
i.ClosedAt = &closedAt
})
statusScope := readerIDFilter(stOpen, stProgress, stBlocked, stClosed)
molType := func(m types.MolType) *publicops.MolType { return &m }
scoped := func(ids ...string) publicops.ListRequest {
return publicops.ListRequest{IDFilter: readerIDFilter(ids...), AllFlag: true}
}
with := func(req publicops.ListRequest, mutate func(*publicops.ListRequest)) publicops.ListRequest {
mutate(&req)
return req
}
for _, test := range []struct {
name string
req publicops.ListRequest
want []string
}{
{"Priority is exact", with(scoped(p0, p2, p4), func(r *publicops.ListRequest) { r.Priority = intp(2) }), []string{p2}},
{"Priority 0 is a value, not unset", with(scoped(p0, p2, p4), func(r *publicops.ListRequest) { r.Priority = intp(0) }), []string{p0}},
{"PriorityMin is inclusive", with(scoped(p0, p2, p4), func(r *publicops.ListRequest) { r.PriorityMin = intp(2) }), []string{p2, p4}},
{"PriorityMax is inclusive", with(scoped(p0, p2, p4), func(r *publicops.ListRequest) { r.PriorityMax = intp(2) }), []string{p0, p2}},
{"PriorityMin and PriorityMax compose", with(scoped(p0, p2, p4), func(r *publicops.ListRequest) { r.PriorityMin, r.PriorityMax = intp(1), intp(3) }), []string{p2}},
{"TitleContains is a case-insensitive substring", with(scoped(textT, textD, textN), func(r *publicops.ListRequest) { r.TitleContains = "TTOK-LFF" }), []string{textT}},
{"DescContains reads the description only", with(scoped(textT, textD, textN), func(r *publicops.ListRequest) { r.DescContains = "dtok-lff" }), []string{textD}},
{"NotesContains reads the notes only", with(scoped(textT, textD, textN), func(r *publicops.ListRequest) { r.NotesContains = "ntok-lff" }), []string{textN}},
{"EmptyDesc keeps the rows with no description", with(scoped(textT, textD, textN), func(r *publicops.ListRequest) { r.EmptyDesc = true }), []string{textT, textN}},
{"NoLabels keeps the unlabeled row", with(scoped(labeled, unlabeled), func(r *publicops.ListRequest) { r.NoLabels = true }), []string{unlabeled}},
{"LabelPattern is a glob", with(scoped(labeled, unlabeled), func(r *publicops.ListRequest) { r.LabelPattern = fixture.IssuePrefix + "-scope-lff*" }), []string{labeled}},
{"LabelRegex is a regular expression", with(scoped(labeled, unlabeled), func(r *publicops.ListRequest) { r.LabelRegex = "-scope-lffp.t$" }), []string{labeled}},
{"NoParent keeps the top-level rows", with(scoped(parent, child, loose), func(r *publicops.ListRequest) { r.NoParent = true }), []string{parent, loose}},
{"ExcludeTypes drops the named type", with(scoped(typeTask, typeBug, typeChore), func(r *publicops.ListRequest) { r.ExcludeTypes = []string{"bug"} }), []string{typeTask, typeChore}},
{"ExcludeTypes takes a comma-separated value", with(scoped(typeTask, typeBug, typeChore), func(r *publicops.ListRequest) { r.ExcludeTypes = []string{"bug,chore"} }), []string{typeTask}},
{"SpecPrefix is a prefix", with(scoped(specced, unspecced), func(r *publicops.ListRequest) { r.SpecPrefix = spec }), []string{specced}},
{"ExternalContains is a case-insensitive substring", with(scoped(extRow, extOther), func(r *publicops.ListRequest) { r.ExternalContains = "lff-EXT" }), []string{extRow}},
{"ExternalRef is exact", with(scoped(extRow, extOther), func(r *publicops.ListRequest) { r.ExternalRef = external }), []string{extRow}},
{"AllFlag alone admits both pinned-flag states", scoped(pinned, unpinned), []string{pinned, unpinned}},
{"PinnedFlag selects the flagged row", publicops.ListRequest{IDFilter: readerIDFilter(pinned, unpinned), PinnedFlag: true}, []string{pinned}},
{"NoPinnedFlag holds the unflagged predicate under AllFlag", with(scoped(pinned, unpinned), func(r *publicops.ListRequest) { r.NoPinnedFlag = true }), []string{unpinned}},
{"DeferredFlag keeps the deferred row", with(scoped(deferred, undeferred), func(r *publicops.ListRequest) { r.DeferredFlag = true }), []string{deferred}},
{"OverdueFlag keeps the open row past its due date", with(scoped(overdue, dueLater, closedOverdue, noDue), func(r *publicops.ListRequest) { r.OverdueFlag = true }), []string{overdue}},
{"ExcludeStatus under AllFlag keeps every status not named", with(scoped(stOpen, stProgress, stBlocked, stClosed), func(r *publicops.ListRequest) { r.ExcludeStatus = []string{"closed"} }), []string{stOpen, stProgress, stBlocked}},
{"ExcludeStatus takes repeated and comma-separated values", with(scoped(stOpen, stProgress, stBlocked, stClosed), func(r *publicops.ListRequest) { r.ExcludeStatus = []string{"blocked,in_progress", " closed "} }), []string{stOpen}},
{"ExcludeStatus adds to the default exclusions rather than replacing them", publicops.ListRequest{IDFilter: statusScope, ExcludeStatus: []string{"blocked"}}, []string{stOpen, stProgress}},
{"ExcludeStatus narrows an explicit Status", publicops.ListRequest{IDFilter: statusScope, Status: "open,blocked,closed", ExcludeStatus: []string{"blocked"}}, []string{stOpen, stClosed}},
{"MolType is exact", with(scoped(swarm, patrol), func(r *publicops.ListRequest) { r.MolType = molType(types.MolTypeSwarm) }), []string{swarm}},
} {
page, err := fixture.Reader.List(ctx, test.req)
if err != nil {
t.Errorf("List (%s): %v", test.name, err)
continue
}
assertReaderPageIDSet(t, "List ("+test.name+")", page, test.want)
}
// An exclusion naming no status in the workspace vocabulary is refused,
// never an exclusion that silently excludes nothing.
if _, err := fixture.Reader.List(ctx, publicops.ListRequest{IDFilter: statusScope, ExcludeStatus: []string{"clsoed"}}); !errors.Is(err, publicops.ErrValidation) {
t.Errorf("List with ExcludeStatus naming an unknown status = %v, want an error wrapping ErrValidation", err)
}
_, err := fixture.Reader.List(ctx, publicops.ListRequest{
IDFilter: readerIDFilter(pinned, unpinned), PinnedFlag: true, NoPinnedFlag: true,
})
if !errors.Is(err, publicops.ErrValidation) {
t.Errorf("List with PinnedFlag and NoPinnedFlag = %v, want an error wrapping ErrValidation", err)
}
_, err = fixture.Reader.List(ctx, publicops.ListRequest{
IDFilter: readerIDFilter(parent, child, loose), ParentID: parent, NoParent: true,
})
if !errors.Is(err, publicops.ErrValidation) {
t.Errorf("List with ParentID and NoParent = %v, want an error wrapping ErrValidation", err)
}
}
// sortedCopy returns its arguments as a sorted slice.
func sortedCopy(ids ...string) []string {
out := slices.Clone(ids)
slices.Sort(out)
return out
}
// readerIssue builds the seed every case starts from: an open, unassigned,
// unblocked task that qualifies for ready work. A case that needs it to fail one
// of those tests changes the field it means to test and nothing else.

View file

@ -769,21 +769,7 @@ type EpochFixture struct {
// Version now resolves to under the new epoch. A nil hook means this
// backend cannot report that, and the case that needs it skips with
// that reason.
//
// It only reads: it mints nothing and changes no state. It returns the
// address it was given when nothing carried the Version to a new one,
// and an error for an address the store does not serve.
CurrentAddressFor func(ctx context.Context, storeID string, oldAddress Address) (Address, error)
// LoseVersion records that storeID no longer serves the Version named by
// address. That address, and every address the same Version was carried
// to or from by a token-scheme change, resolves GoneReorganization from
// then on, in every later epoch: an epoch voids what the store lost,
// never what it still serves (R20-n). It is idempotent, never revives
// anything, and returns an error for an address storeID never minted. A
// nil LoseVersion means this backend cannot record a loss, and the cases
// that need one skip with that reason.
LoseVersion func(ctx context.Context, storeID string, address Address) error
}
// RunAnEpochBumpIsTriggeredOnlyByRestoreReinitOrSchemeChange pins R20-m: a
@ -833,258 +819,94 @@ func RunAnEpochBumpIsTriggeredOnlyByRestoreReinitOrSchemeChange(t *testing.T, ct
// RunEpochBumpVoidsOnlyAddressesOfVersionsNoLongerServed pins R20-n — "Rev7
// tightening... the clause most likely to be gotten wrong" in the
// architecture doc's own words: an epoch voids what the store lost, never
// what it still serves.
// architecture doc's own words. A prior-epoch Address goes
// GoneReorganization UNLESS the backend still serves that Version, in which
// case it must stay Live AND additionally report the Address it now
// resolves to under the new epoch.
//
// Survival is RECORDED, never inferred (gastownhall/beads#6664, bee-ghosttrack
// review 5360880888, Major 1). An earlier form of this case made a Version
// survive by minting it again in every later epoch, and treated a Version
// nobody minted again as lost. That reads loss off the absence of a mint, so
// it could not express a Version the store lost after minting it, and it
// voided every survivor that nobody happened to mint again. Here a restore or
// a destructive reinit leaves every address row alone: an address the store
// still serves stays Live at its own address with no upkeep, and the only way
// an address goes Gone is LoseVersion saying so.
//
// Each phase is a named subtest, so a backend that cannot record a loss skips
// only the phases that need LoseVersion, and a failure names its phase.
// StillServes is an ORACLE here, not a control: this case cannot make a real
// backend keep serving one address and drop another, since Phase 0 wires no
// real backend. It asks StillServes what the fixture (once real) decided,
// and checks the rest of the contract's promise against that decision for
// both outcomes.
func RunEpochBumpVoidsOnlyAddressesOfVersionsNoLongerServed(t *testing.T, ctx context.Context, fixture EpochFixture) {
t.Helper()
epochSkipUnlessReady(t, fixture, false)
// survivor-and-lost: of two Versions minted before a transition, the one
// the store loses goes Gone and the other stays Live at the address it
// already had, with no re-mint, for both triggers that leave addresses
// alone.
t.Run("survivor-and-lost", func(t *testing.T) {
if fixture.LoseVersion == nil {
t.Skip(epochLoseVersionSkip)
}
for _, trigger := range []EpochBumpTrigger{EpochBumpTriggerRestore, EpochBumpTriggerDestructiveReinit} {
t.Run(trigger.String(), func(t *testing.T) {
store := epochStore(fixture, "survivor-"+trigger.String())
addrA := epochMintAddress(t, ctx, fixture, store, "record-a")
addrB := epochMintAddress(t, ctx, fixture, store, "record-b")
newEpoch := epochBumpTo(t, ctx, fixture, store, trigger)
epochLoseAddress(t, ctx, fixture, store, addrB)
epochRequireLive(t, ctx, fixture, store, addrA, newEpoch,
"record-a was never lost, so the transition leaves it served at its own address with no re-mint (R20-n's exception)")
epochRequireGone(t, ctx, fixture, store, addrB, newEpoch,
"record-b was lost, so the transition voids it (R20-n)")
current := epochCurrentAddress(t, ctx, fixture, store, addrA)
epochRequireLive(t, ctx, fixture, store, current, newEpoch,
"the address CurrentAddressFor reports for a survivor must be served")
epochRequireLive(t, ctx, fixture, store, addrA, newEpoch,
"asking CurrentAddressFor must not retire or move the survivor's address")
if lostCurrent, err := fixture.CurrentAddressFor(ctx, store, addrB); err == nil {
t.Errorf("CurrentAddressFor(a lost address) = %s with no error, want an error: a lost Version has no current address", lostCurrent)
}
epochRequireGone(t, ctx, fixture, store, addrB, newEpoch,
"CurrentAddressFor on a lost address must not bring it back")
})
}
})
// gone-is-terminal: once an address is lost it stays lost. A later mint of
// the same id starts a new lineage under a new address, and neither that
// mint nor CurrentAddressFor revives the lost one (bee-ghosttrack's
// assertion for Major 1: a read-only lookup must not mint a replacement
// that makes a lost address look served).
t.Run("gone-is-terminal", func(t *testing.T) {
if fixture.LoseVersion == nil {
t.Skip(epochLoseVersionSkip)
}
store := epochStore(fixture, "terminal")
lost := epochMintAddress(t, ctx, fixture, store, "record-g")
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
epochLoseAddress(t, ctx, fixture, store, lost)
laterEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
fresh := epochMintAddress(t, ctx, fixture, store, "record-g")
if fresh == lost {
t.Fatalf("MintUnderEpoch(record-g) returned %s, the address already lost: a lost address is never handed out again", lost)
}
epochRequireLive(t, ctx, fixture, store, fresh, laterEpoch,
"a fresh mint of the id is a new lineage and is served")
epochRequireGone(t, ctx, fixture, store, lost, laterEpoch,
"a later mint of the same id must not revive a lost address")
if replacement, err := fixture.CurrentAddressFor(ctx, store, lost); err == nil {
t.Errorf("CurrentAddressFor(a lost address) = %s with no error, want an error: asking where a lost address resolves must not mint a replacement", replacement)
}
epochRequireGone(t, ctx, fixture, store, lost, laterEpoch,
"CurrentAddressFor on a lost address must not revive it")
// Losing it a second time is a no-op that leaves the fresh lineage
// alone.
epochLoseAddress(t, ctx, fixture, store, lost)
epochRequireLive(t, ctx, fixture, store, fresh, laterEpoch,
"losing the old address again must leave the fresh lineage served")
})
// survival-needs-no-upkeep: with nothing lost, an address stays Live across
// any number of counter-only transitions without being minted again, and a
// later mint of the same id neither retires it nor revives anything. This
// is the phase the earlier, mint-driven form failed: it answered Gone for
// every survivor nobody minted again.
t.Run("survival-needs-no-upkeep", func(t *testing.T) {
store := epochStore(fixture, "upkeep")
kept := epochMintAddress(t, ctx, fixture, store, "record-c")
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerDestructiveReinit)
finalEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
epochRequireLive(t, ctx, fixture, store, kept, finalEpoch,
"nothing was lost, so three counter-only transitions leave the address served without a re-mint")
fresh := epochMintAddress(t, ctx, fixture, store, "record-c")
if fresh == kept {
t.Fatalf("MintUnderEpoch(record-c) returned %s again after three bumps, want a new address for the new epoch", kept)
}
epochRequireLive(t, ctx, fixture, store, kept, finalEpoch,
"a later mint of the same id must not retire a served address")
epochRequireLive(t, ctx, fixture, store, fresh, finalEpoch,
"the fresh mint is served")
current := epochCurrentAddress(t, ctx, fixture, store, kept)
epochRequireLive(t, ctx, fixture, store, current, finalEpoch,
"the current address of a survivor must be served")
epochRequireLive(t, ctx, fixture, store, kept, finalEpoch,
"asking for the current address must not change the survivor")
})
}
// RunTokenSchemeChangeCarriesLiveAddressesAndOnlyThose pins R20-n's retained
// mapping for the one trigger that changes how addresses are encoded. A
// token-scheme-change bump gives every Version the store still serves a new
// address under the new epoch and keeps the old address resolving, so a holder
// of the old address is neither stranded nor pointed at something else. A
// Version the store already lost gets no new address and stays Gone.
func RunTokenSchemeChangeCarriesLiveAddressesAndOnlyThose(t *testing.T, ctx context.Context, fixture EpochFixture) {
t.Helper()
epochSkipUnlessReady(t, fixture, true)
store := epochStore(fixture, "scheme-change")
addrA := epochMintAddress(t, ctx, fixture, store, "record-a")
addrB := epochMintAddress(t, ctx, fixture, store, "record-b")
// record-b is lost in the epoch it was minted in, which a store may do.
epochLoseAddress(t, ctx, fixture, store, addrB)
newEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerTokenSchemeChange)
epochRequireLive(t, ctx, fixture, store, addrA, newEpoch,
"record-a is still served after the scheme change, through the retained mapping")
epochRequireGone(t, ctx, fixture, store, addrB, newEpoch,
"record-b was lost before the scheme change, which must not carry it")
carried := epochCurrentAddress(t, ctx, fixture, store, addrA)
if carried == addrA {
t.Errorf("CurrentAddressFor(%s) = the same address after a token-scheme change, want a new one: a scheme change re-encodes every served address, which is what tells a carry from a no-op", addrA)
if fixture.MintUnderEpoch == nil {
t.Skip("this backend has no way to mint a Version under a known epoch (MintUnderEpoch is nil)")
}
epochRequireLive(t, ctx, fixture, store, carried, newEpoch,
"the carried address must be served under the new epoch")
epochRequireLive(t, ctx, fixture, store, addrA, newEpoch,
"the old address must keep resolving after its carried address is looked up")
if again := epochCurrentAddress(t, ctx, fixture, store, carried); again != carried {
t.Errorf("CurrentAddressFor(%s) = %s, want the carried address itself: from the newest address the mapping is already current", carried, again)
if fixture.BumpEpoch == nil {
t.Skip("this backend has no epoch concept yet (BumpEpoch is nil)")
}
if lostCurrent, err := fixture.CurrentAddressFor(ctx, store, addrB); err == nil {
t.Errorf("CurrentAddressFor(a lost address) = %s with no error, want an error: a lost Version is not carried", lostCurrent)
if fixture.StillServes == nil {
t.Skip("this backend cannot report whether it still serves a prior-epoch Version (StillServes is nil)")
}
}
if fixture.Resolve == nil {
t.Skip("this backend does not yet report retention state (Resolve is nil)")
}
if fixture.CurrentAddressFor == nil {
t.Skip("this backend cannot report a still-served Version's new Address (CurrentAddressFor is nil)")
}
store := epochStore(fixture, "voids")
// RunACarriedAddressKeepsResolvingAcrossLaterBumps pins that a carried mapping
// is recorded once and then simply persists: later counter-only transitions do
// not change it, and a second token-scheme change extends it to the newest
// address without breaking any older one. Every address of the Version points
// directly at the newest address (one hop from any member), never along a
// chain.
func RunACarriedAddressKeepsResolvingAcrossLaterBumps(t *testing.T, ctx context.Context, fixture EpochFixture) {
t.Helper()
epochSkipUnlessReady(t, fixture, false)
store := epochStore(fixture, "carried-later")
addrA := epochMintAddress(t, ctx, fixture, store, "record-a")
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerTokenSchemeChange)
addrA1 := epochCurrentAddress(t, ctx, fixture, store, addrA)
if addrA1 == addrA {
t.Fatalf("CurrentAddressFor(%s) = the same address after a token-scheme change, want a new one", addrA)
addrA, err := fixture.MintUnderEpoch(ctx, store, "record-a")
if err != nil {
t.Fatalf("MintUnderEpoch(record-a): %v", err)
}
addrB, err := fixture.MintUnderEpoch(ctx, store, "record-b")
if err != nil {
t.Fatalf("MintUnderEpoch(record-b): %v", err)
}
// Two counter-only transitions, with nothing minted in between.
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
counterEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerDestructiveReinit)
epochRequireLive(t, ctx, fixture, store, addrA, counterEpoch,
"the original address must still resolve after counter-only transitions")
epochRequireLive(t, ctx, fixture, store, addrA1, counterEpoch,
"the carried address must still resolve after counter-only transitions")
if got := epochCurrentAddress(t, ctx, fixture, store, addrA); got != addrA1 {
t.Errorf("CurrentAddressFor(%s) = %s, want %s: a counter-only transition does not change the mapping", addrA, got, addrA1)
newEpoch, err := fixture.BumpEpoch(ctx, store, EpochBumpTriggerRestore)
if err != nil {
t.Fatalf("BumpEpoch: %v", err)
}
// A second scheme change carries the Version again.
secondEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerTokenSchemeChange)
addrA2 := epochCurrentAddress(t, ctx, fixture, store, addrA)
if addrA2 == addrA || addrA2 == addrA1 {
t.Fatalf("CurrentAddressFor(%s) = %s after a second scheme change, want an address different from %s and %s", addrA, addrA2, addrA, addrA1)
servesA, err := fixture.StillServes(ctx, store, addrA)
if err != nil {
t.Fatalf("StillServes(%s): %v", addrA, err)
}
for _, member := range []Address{addrA, addrA1, addrA2} {
epochRequireLive(t, ctx, fixture, store, member, secondEpoch,
"every address of a carried Version must resolve after a second scheme change")
servesB, err := fixture.StillServes(ctx, store, addrB)
if err != nil {
t.Fatalf("StillServes(%s): %v", addrB, err)
}
if got := epochCurrentAddress(t, ctx, fixture, store, addrA1); got != addrA2 {
t.Errorf("CurrentAddressFor(%s) = %s, want %s: every address of the Version points straight at the newest one", addrA1, got, addrA2)
if servesA == servesB {
t.Skip("this scenario needs one still-served and one no-longer-served address to exercise both halves of R20-n; StillServes reported the same answer for both, so this fixture gives this case nothing to contrast")
}
finalEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
epochRequireLive(t, ctx, fixture, store, addrA2, finalEpoch,
"the newest carried address must still resolve after a later restore")
}
// RunALostAddressStaysGoneAcrossASchemeChange pins that loss is terminal even
// across a token-scheme change. Losing a Version loses every address of its
// lineage at once, and a later scheme change must not carry a lost lineage
// back into service.
func RunALostAddressStaysGoneAcrossASchemeChange(t *testing.T, ctx context.Context, fixture EpochFixture) {
t.Helper()
epochSkipUnlessReady(t, fixture, true)
store := epochStore(fixture, "lost-scheme-change")
addrA := epochMintAddress(t, ctx, fixture, store, "record-a")
epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerTokenSchemeChange)
addrA1 := epochCurrentAddress(t, ctx, fixture, store, addrA)
lostEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerRestore)
// One lineage, two addresses: losing either loses both.
epochLoseAddress(t, ctx, fixture, store, addrA)
epochRequireGone(t, ctx, fixture, store, addrA, lostEpoch,
"the original address of a lost Version must be Gone")
epochRequireGone(t, ctx, fixture, store, addrA1, lostEpoch,
"the carried address of a lost Version must be Gone too")
schemeEpoch := epochBumpTo(t, ctx, fixture, store, EpochBumpTriggerTokenSchemeChange)
epochRequireGone(t, ctx, fixture, store, addrA, schemeEpoch,
"a later scheme change must not carry a lost lineage back into service")
epochRequireGone(t, ctx, fixture, store, addrA1, schemeEpoch,
"a later scheme change must not carry a lost lineage back into service")
for _, lostAddress := range []Address{addrA, addrA1} {
if current, err := fixture.CurrentAddressFor(ctx, store, lostAddress); err == nil {
t.Errorf("CurrentAddressFor(%s) = %s with no error, want an error: a lost lineage has no current address", lostAddress, current)
}
stillServed, noLongerServed := addrA, addrB
if servesB && !servesA {
stillServed, noLongerServed = addrB, addrA
}
fresh := epochMintAddress(t, ctx, fixture, store, "record-a")
if fresh == addrA || fresh == addrA1 {
t.Fatalf("MintUnderEpoch(record-a) returned %s, an address of the lost lineage: a lost address is never handed out again", fresh)
voidedAnswer, err := fixture.Resolve(ctx, store, noLongerServed)
if err != nil {
t.Fatalf("Resolve(no-longer-served): %v", err)
}
if voidedAnswer.Restriction != RestrictionGoneReorganization {
t.Errorf("Resolve(a prior-epoch Address no longer served) = %s, want RestrictionGoneReorganization (R20-n)", voidedAnswer.Restriction)
}
if voidedAnswer.Epoch == nil {
t.Fatal("Resolve(a prior-epoch Address no longer served).Epoch = nil, want the current epoch populated (R20-n: the answer must name the current epoch, not just Restriction alone)")
} else if *voidedAnswer.Epoch != newEpoch {
t.Errorf("Resolve(a prior-epoch Address no longer served).Epoch = %d, want the current epoch %d", *voidedAnswer.Epoch, newEpoch)
}
keptAnswer, err := fixture.Resolve(ctx, store, stillServed)
if err != nil {
t.Fatalf("Resolve(still-served): %v", err)
}
if keptAnswer.Restriction != RestrictionLive {
t.Errorf("Resolve(a prior-epoch Address the backend still serves) = %s, want RestrictionLive (R20-n's exception)", keptAnswer.Restriction)
}
newAddr, err := fixture.CurrentAddressFor(ctx, store, stillServed)
if err != nil {
t.Fatalf("CurrentAddressFor(%s): %v", stillServed, err)
}
if newAddr == "" {
t.Error("CurrentAddressFor(a still-served prior-epoch Address) returned an empty Address, want a real one under the new epoch")
}
epochRequireLive(t, ctx, fixture, store, fresh, schemeEpoch,
"a fresh mint of the id after the loss is a new lineage and is served")
}
// --- fixture helpers -------------------------------------------------------
@ -1131,137 +953,6 @@ func epochStore(fixture EpochFixture, tag string) string {
return fixture.IssuePrefix + "-epoch-store-" + tag
}
// epochLoseVersionSkip is the skip reason of every phase that needs
// EpochFixture.LoseVersion.
const epochLoseVersionSkip = "this backend cannot record that the store lost a Version (LoseVersion is nil)"
// epochSkipUnlessReady skips the case when the fixture lacks a capability the
// epoch cases need. The cases that record a loss also need LoseVersion. The
// all-nil wiring test runs every case against an empty fixture, so each case
// must call this before it touches any of them.
func epochSkipUnlessReady(t *testing.T, fixture EpochFixture, needsLoseVersion bool) {
t.Helper()
if fixture.MintUnderEpoch == nil {
t.Skip("this backend has no way to mint a Version under a known epoch (MintUnderEpoch is nil)")
}
if fixture.BumpEpoch == nil {
t.Skip("this backend has no epoch concept yet (BumpEpoch is nil)")
}
if fixture.StillServes == nil {
t.Skip("this backend cannot report whether it still serves a prior-epoch Version (StillServes is nil)")
}
if fixture.Resolve == nil {
t.Skip("this backend does not yet report retention state (Resolve is nil)")
}
if fixture.CurrentAddressFor == nil {
t.Skip("this backend cannot report a still-served Version's new Address (CurrentAddressFor is nil)")
}
if needsLoseVersion && fixture.LoseVersion == nil {
t.Skip(epochLoseVersionSkip)
}
}
// epochMintAddress mints id on store, failing the case if minting fails.
func epochMintAddress(t *testing.T, ctx context.Context, fixture EpochFixture, store, id string) Address {
t.Helper()
address, err := fixture.MintUnderEpoch(ctx, store, id)
if err != nil {
t.Fatalf("MintUnderEpoch(%s, %s): %v", store, id, err)
}
return address
}
// epochBumpTo bumps store's epoch for trigger and returns the epoch it
// reports. Epochs are captured from the return value, never assumed: the
// counter is one per database, shared by every store the suite uses.
func epochBumpTo(t *testing.T, ctx context.Context, fixture EpochFixture, store string, trigger EpochBumpTrigger) int {
t.Helper()
epoch, err := fixture.BumpEpoch(ctx, store, trigger)
if err != nil {
t.Fatalf("BumpEpoch(%s, %s): %v", store, trigger, err)
}
return epoch
}
// epochLoseAddress records that store lost the Version behind address.
func epochLoseAddress(t *testing.T, ctx context.Context, fixture EpochFixture, store string, address Address) {
t.Helper()
if err := fixture.LoseVersion(ctx, store, address); err != nil {
t.Fatalf("LoseVersion(%s, %s): %v", store, address, err)
}
}
// epochCurrentAddress asks where address now resolves, failing the case on an
// error or an empty answer.
func epochCurrentAddress(t *testing.T, ctx context.Context, fixture EpochFixture, store string, address Address) Address {
t.Helper()
current, err := fixture.CurrentAddressFor(ctx, store, address)
if err != nil {
t.Fatalf("CurrentAddressFor(%s, %s): %v", store, address, err)
}
if current == "" {
t.Fatalf("CurrentAddressFor(%s, %s) returned an empty Address, want a real one", store, address)
}
return current
}
// epochRequireLive asserts that address is served at epoch: StillServes is true
// and Resolve answers RestrictionLive naming that epoch. why says what the
// assertion is checking, for the failure message.
func epochRequireLive(t *testing.T, ctx context.Context, fixture EpochFixture, store string, address Address, epoch int, why string) {
t.Helper()
serves, err := fixture.StillServes(ctx, store, address)
if err != nil {
t.Fatalf("StillServes(%s): %v", address, err)
}
if !serves {
t.Errorf("StillServes(%s) = false, want true: %s", address, why)
}
answer, err := fixture.Resolve(ctx, store, address)
if err != nil {
t.Fatalf("Resolve(%s): %v", address, err)
}
if answer.Restriction != RestrictionLive {
t.Errorf("Resolve(%s) = %s, want RestrictionLive: %s", address, answer.Restriction, why)
}
epochRequireAnswerEpoch(t, answer, address, epoch, why)
}
// epochRequireGone asserts that address is no longer served at epoch:
// StillServes is false and Resolve answers RestrictionGoneReorganization
// naming that epoch.
func epochRequireGone(t *testing.T, ctx context.Context, fixture EpochFixture, store string, address Address, epoch int, why string) {
t.Helper()
serves, err := fixture.StillServes(ctx, store, address)
if err != nil {
t.Fatalf("StillServes(%s): %v", address, err)
}
if serves {
t.Errorf("StillServes(%s) = true, want false: %s", address, why)
}
answer, err := fixture.Resolve(ctx, store, address)
if err != nil {
t.Fatalf("Resolve(%s): %v", address, err)
}
if answer.Restriction != RestrictionGoneReorganization {
t.Errorf("Resolve(%s) = %s, want RestrictionGoneReorganization: %s", address, answer.Restriction, why)
}
epochRequireAnswerEpoch(t, answer, address, epoch, why)
}
// epochRequireAnswerEpoch asserts that a Live or Gone answer names the current
// epoch (R20-n: the answer carries the epoch, not just the Restriction).
func epochRequireAnswerEpoch(t *testing.T, answer RetentionAnswer, address Address, epoch int, why string) {
t.Helper()
if answer.Epoch == nil {
t.Errorf("Resolve(%s).Epoch = nil, want the current epoch %d: %s", address, epoch, why)
return
}
if *answer.Epoch != epoch {
t.Errorf("Resolve(%s).Epoch = %d, want the current epoch %d: %s", address, *answer.Epoch, epoch, why)
}
}
// sameRetentionAnswer compares two RetentionAnswer values by content rather
// than identity, so a case can assert "this did not change" without
// depending on the concrete Restriction the backend happened to pick.

View file

@ -604,8 +604,6 @@ var roleContractCases = []roleContract{
RunReaderListWispTypeNarrowsTheAdmittedPlaneRatherThanAdmittingIt,
RunReaderListBriefDropsTheFreeFormTextAndNothingElse,
RunReaderReadyBriefDropsTheFreeFormTextAndNothingElse,
RunReaderListTimeBoundsAreStrictAndWholeSecond,
RunReaderListFilterFamiliesNarrowToTheirRows,
),
roleCases("ReadyClaimer", "ReadyClaimer() and IssueReader()", oncePerRole,

View file

@ -129,14 +129,5 @@ func TestVersionedHistoryPhase0RunsInFullSkipMode(t *testing.T) {
t.Run("EpochBumpVoidsOnlyAddressesOfVersionsNoLongerServed", func(t *testing.T) {
RunEpochBumpVoidsOnlyAddressesOfVersionsNoLongerServed(t, ctx, fixture)
})
t.Run("TokenSchemeChangeCarriesLiveAddressesAndOnlyThose", func(t *testing.T) {
RunTokenSchemeChangeCarriesLiveAddressesAndOnlyThose(t, ctx, fixture)
})
t.Run("ACarriedAddressKeepsResolvingAcrossLaterBumps", func(t *testing.T) {
RunACarriedAddressKeepsResolvingAcrossLaterBumps(t, ctx, fixture)
})
t.Run("ALostAddressStaysGoneAcrossASchemeChange", func(t *testing.T) {
RunALostAddressStaysGoneAcrossASchemeChange(t, ctx, fixture)
})
})
}

View file

@ -1,356 +0,0 @@
package conformance
import (
"context"
"testing"
"time"
)
// This file holds the contract for R7.1 (gastownhall/beads#6136, design doc
// gastownhall/beads#5898 revision 9): the as-of read — the "versioned
// reads" half of Phase 3's title, authored here from scratch, since no
// fixture for it exists anywhere in this package to un-skip.
//
// R7.1, VERBATIM (design doc #5898 rev 9): "An as-of read is a named read
// whose selector is an instant. Given an instant T or a version address, a
// store returns one Bead's durable state as of that point — the latest
// version it holds that was accepted at or before T, with everything later
// excluded — under R7's record shape, marking the address it served, or
// refuses as gone or unknown with the reason (R8, R20). Like every history
// answer it is complete for the answering store's holdings and may change
// after a sync (TC3)."
//
// ADDRESS, RESTRICTION, AND CHANGEATTRIBUTION ARE DECLARED IN
// expected_revision_contract.go — see that file's package-level note on
// where this suite's shared vocabulary lives and why. This file reuses
// Restriction's five values as-is for the gone-or-unknown refusal outcome
// (R8): an as-of read never invents a sixth state, and never distinguishes
// "gone" from "unknown" any differently than R20 already does.
//
// EVERY HOOK ON THE FIXTURE BELOW IS INDEPENDENTLY NILABLE — see the
// package-level note in expected_revision_contract.go. Every case
// nil-checks every hook it uses and SKIPS BY NAME when one is missing. No
// backend implements as-of reads yet — the implementation is
// the child this suite is written ahead of.
//
// EXPLICIT NON-GOAL: MEMORY-PLANE CONSUMER POLICY IS NOT PART OF THIS
// PRIMITIVE. R7.1's own text is explicit that a closed-before-T boundary,
// sibling exclusion, and supersession exclusion "are Memory-plane policies
// a consumer layers on this primitive (#5877), not part of it." This suite
// does not implement or assert any of the three — a future reader who finds
// them absent should read that as this file honoring R7.1's own scope, not
// as an oversight. This is the read-side analog of the R16/R16.1 boundary
// risk already recorded in expected_revision_contract.go: do not conflate
// the primitive with policy layered on top of it.
//
// THIS SUITE ASSERTS LOCAL COMPLETENESS ONLY (TC3). Nothing below requires,
// or even checks, that two stores asked about the same lineage agree — R7.1
// itself says an as-of answer "may change after a sync," so two stores at
// different sync points are expected to answer differently, and neither is
// wrong. RunAsOfReadIsCompleteOnlyForTheAnsweringStoresHoldings is the one
// case that touches more than one store, and what it asserts is exactly
// this: each store answers strictly from its own holdings, never a
// sibling's — not that the two agree.
// AsOfSelector names the point R7.1 resolves against: either a wall-clock
// instant, or a specific version Address treated as the selector itself —
// "the read that names its own answer" (R7.1: "an instant T or a version
// address"). Exactly one of At/Version is populated in every case this file
// exercises; R7.1 does not speak to the shape where both or neither are
// set, so this suite does not either.
type AsOfSelector struct {
At *time.Time
Version *Address
}
// AsOfReadRefusal is R8's typed outcome for an as-of read that cannot be
// answered. Restriction is always one of the four Gone*/Unknown values,
// never RestrictionLive — a live answer is a served AsOfReadResult, not a
// refusal. Reason explains why (R8).
type AsOfReadRefusal struct {
Restriction Restriction
Reason string
}
// AsOfReadResult is the outcome of an as-of read (R7.1). Address/State and
// Refusal are mutually exclusive: read Address/State only when Refusal is
// nil.
type AsOfReadResult struct {
// Address is the version this read served, marking "the address it
// served" (R7.1). Populated only when Refusal is nil.
Address Address
// State is the served version's durable state under R7's record shape.
// Opaque to this suite: the fixture adapter translates a backend's real
// record shape into this map, and no case here asserts its field-level
// content — only that a served result carries an Address.
State map[string]any
// Refusal is populated instead of Address/State when the read cannot be
// answered (R8). Nil means the read was served.
Refusal *AsOfReadRefusal
}
// AsOfRead resolves storeID's answer to an as-of read against id's lineage,
// at selector (R7.1).
type AsOfRead func(ctx context.Context, storeID, id string, selector AsOfSelector) (AsOfReadResult, error)
// AsOfReadFixture supplies the capability under test for R7.1: a read whose
// selector is an instant or a version address, resolving to the latest
// version accepted at or before that point, or a typed refusal.
type AsOfReadFixture struct {
IssuePrefix string
// Resolve performs the as-of read under test (R7.1). A nil hook means
// this backend does not implement as-of reads yet, and every case in
// this file skips with that reason.
Resolve AsOfRead
// MintAt mints a fresh version for id under storeID, recorded as
// accepted at the given instant, and returns its Address. Cases use
// this to build a lineage with known accept-times to resolve an as-of
// read against. A nil hook means this backend has no way to mint a
// version at a controlled accept-time, and cases that need one skip
// with that reason.
MintAt func(ctx context.Context, storeID, id string, acceptedAt time.Time) (Address, error)
// MakeUnanswerable arranges for id to be unanswerable at storeID for
// the given Restriction (one of RestrictionGoneRetention/GoneErasure/
// GoneReorganization/Unknown) — independently of
// RetentionFixture/EpochFixture's own removal machinery, since R7.1's
// refusal is a sibling contract to R17/R20, not a dependent of them. A
// nil hook means this backend has no way to arrange this, and the case
// that needs it skips with that reason.
MakeUnanswerable func(ctx context.Context, storeID, id string, restriction Restriction) error
}
// RunAsOfReadSelectorAcceptsEitherAnInstantOrAVersionAddress pins R7.1's
// selector shape: an instant T and the version address that instant
// resolves to are two names for the same answer, and a store must accept
// either.
func RunAsOfReadSelectorAcceptsEitherAnInstantOrAVersionAddress(t *testing.T, ctx context.Context, fixture AsOfReadFixture) {
t.Helper()
if fixture.Resolve == nil {
t.Skip("this backend does not implement as-of reads (Resolve is nil)")
}
if fixture.MintAt == nil {
t.Skip("this backend has no way to mint a version at a controlled accept-time (MintAt is nil)")
}
store := asOfReadStore(fixture, "selector-kinds")
id := fixture.IssuePrefix + "-asof-selector"
t0 := time.Now().UTC().Add(-time.Hour)
asOfReadMint(t, ctx, fixture, store, id, t0)
t1 := t0.Add(time.Minute)
second := asOfReadMint(t, ctx, fixture, store, id, t1)
byInstant, err := fixture.Resolve(ctx, store, id, AsOfSelector{At: &t1})
if err != nil {
t.Fatalf("Resolve(selector=instant): %v", err)
}
if byInstant.Refusal != nil {
t.Fatalf("Resolve(selector=instant) = %+v, want a served result", byInstant)
}
byVersion, err := fixture.Resolve(ctx, store, id, AsOfSelector{Version: &second})
if err != nil {
t.Fatalf("Resolve(selector=version address): %v", err)
}
if byVersion.Refusal != nil {
t.Fatalf("Resolve(selector=version address) = %+v, want a served result", byVersion)
}
if byInstant.Address != second {
t.Errorf("Resolve(selector=instant matching a version's own accept-time).Address = %s, want %s", byInstant.Address, second)
}
if byVersion.Address != second {
t.Errorf("Resolve(selector=version address).Address = %s, want the same address named %s", byVersion.Address, second)
}
if byInstant.Address != byVersion.Address {
t.Errorf("an instant selector (served %s) and a version-address selector naming the same version (served %s) resolved to different addresses; R7.1 accepts either as a name for the same answer", byInstant.Address, byVersion.Address)
}
}
// RunAsOfReadReturnsTheLatestVersionAtOrBeforeTStrictlyExcludingLater pins
// R7.1's ordering promise: resolving at T returns the latest version
// accepted at or before T, and a version accepted after T is excluded even
// when its own instant is close by.
func RunAsOfReadReturnsTheLatestVersionAtOrBeforeTStrictlyExcludingLater(t *testing.T, ctx context.Context, fixture AsOfReadFixture) {
t.Helper()
if fixture.Resolve == nil {
t.Skip("this backend does not implement as-of reads (Resolve is nil)")
}
if fixture.MintAt == nil {
t.Skip("this backend has no way to mint a version at a controlled accept-time (MintAt is nil)")
}
store := asOfReadStore(fixture, "ordering")
id := fixture.IssuePrefix + "-asof-ordering"
t0 := time.Now().UTC().Add(-time.Hour)
asOfReadMint(t, ctx, fixture, store, id, t0)
t1 := t0.Add(time.Minute)
middle := asOfReadMint(t, ctx, fixture, store, id, t1)
t2 := t0.Add(2 * time.Minute)
asOfReadMint(t, ctx, fixture, store, id, t2)
atExactly, err := fixture.Resolve(ctx, store, id, AsOfSelector{At: &t1})
if err != nil {
t.Fatalf("Resolve(T=middle's own instant): %v", err)
}
if atExactly.Refusal != nil || atExactly.Address != middle {
t.Errorf("Resolve(T=middle's own instant) = %+v, want the version accepted exactly at T (%s), not a later one", atExactly, middle)
}
between := t1.Add(30 * time.Second)
betweenResult, err := fixture.Resolve(ctx, store, id, AsOfSelector{At: &between})
if err != nil {
t.Fatalf("Resolve(T strictly between two versions): %v", err)
}
if betweenResult.Refusal != nil || betweenResult.Address != middle {
t.Errorf("Resolve(T strictly between two versions) = %+v, want the latest version at-or-before T (%s); the version accepted after T must be strictly excluded", betweenResult, middle)
}
}
// RunAsOfReadReportsTheAddressItServed pins R7.1's "marking the address it
// served": a served result names the exact Address of the version it
// returned, not merely a truthy success.
func RunAsOfReadReportsTheAddressItServed(t *testing.T, ctx context.Context, fixture AsOfReadFixture) {
t.Helper()
if fixture.Resolve == nil {
t.Skip("this backend does not implement as-of reads (Resolve is nil)")
}
if fixture.MintAt == nil {
t.Skip("this backend has no way to mint a version at a controlled accept-time (MintAt is nil)")
}
store := asOfReadStore(fixture, "reports-address")
id := fixture.IssuePrefix + "-asof-reports-address"
at := time.Now().UTC()
address := asOfReadMint(t, ctx, fixture, store, id, at)
result, err := fixture.Resolve(ctx, store, id, AsOfSelector{At: &at})
if err != nil {
t.Fatalf("Resolve: %v", err)
}
if result.Refusal != nil {
t.Fatalf("Resolve = %+v, want a served result", result)
}
if result.Address == "" {
t.Fatal("Resolve returned an empty Address on a served result, want the address of the version it served (R7.1)")
}
if result.Address != address {
t.Errorf("Resolve(...).Address = %s, want the served version's own address %s", result.Address, address)
}
}
// RunAsOfReadRefusesAsGoneOrUnknownNeverSubstitutingAnotherVersion pins R8:
// a read that cannot be answered refuses as a typed Gone or Unknown outcome
// with a reason, and never silently returns a neighboring version, the
// nearest surviving version, or current state as a substitute — R8's own
// text names all three as non-answers.
func RunAsOfReadRefusesAsGoneOrUnknownNeverSubstitutingAnotherVersion(t *testing.T, ctx context.Context, fixture AsOfReadFixture) {
t.Helper()
if fixture.Resolve == nil {
t.Skip("this backend does not implement as-of reads (Resolve is nil)")
}
if fixture.MintAt == nil {
t.Skip("this backend has no way to mint a version at a controlled accept-time (MintAt is nil)")
}
if fixture.MakeUnanswerable == nil {
t.Skip("this backend has no way to make a lineage unanswerable (MakeUnanswerable is nil)")
}
for _, restriction := range []Restriction{
RestrictionGoneRetention,
RestrictionGoneErasure,
RestrictionGoneReorganization,
RestrictionUnknown,
} {
t.Run(restriction.String(), func(t *testing.T) {
store := asOfReadStore(fixture, "unanswerable-"+restriction.String())
id := fixture.IssuePrefix + "-asof-unanswerable-" + restriction.String()
at := time.Now().UTC()
address := asOfReadMint(t, ctx, fixture, store, id, at)
if err := fixture.MakeUnanswerable(ctx, store, id, restriction); err != nil {
t.Fatalf("MakeUnanswerable(%s, %s): %v", id, restriction, err)
}
result, err := fixture.Resolve(ctx, store, id, AsOfSelector{At: &at})
if err != nil {
t.Fatalf("Resolve after MakeUnanswerable(%s): %v", restriction, err)
}
if result.Refusal == nil {
t.Fatalf("Resolve after MakeUnanswerable(%s) = %+v, want a Refusal, not a served result (R8)", restriction, result)
}
if result.Refusal.Restriction != restriction {
t.Errorf("Refusal.Restriction = %s, want %s", result.Refusal.Restriction, restriction)
}
if result.Refusal.Reason == "" {
t.Error("Refusal.Reason is empty, want a reason (R8)")
}
if result.Address != "" {
t.Errorf("Resolve on a refusal returned Address = %s, want empty: R8 forbids silently substituting a neighboring version, the nearest surviving version, or current state (the pre-refusal address was %s)", result.Address, address)
}
})
}
}
// RunAsOfReadIsCompleteOnlyForTheAnsweringStoresHoldings pins R7.1's closing
// clause and TC3: an as-of answer "is complete for the answering store's
// holdings and may change after a sync." This case asserts NOTHING about
// agreement between two stores asked about the same lineage — proving that
// absence is the point, not a gap. It mints a lineage into exactly one of
// two stores and confirms each store answers strictly from its own
// holdings: the store that holds the lineage serves it, and the store that
// never received it answers Unknown (FR-06, reused from R20) rather than
// reaching across to a sibling store's knowledge, erroring, or answering
// Gone — which would claim knowledge of a lineage it never held.
func RunAsOfReadIsCompleteOnlyForTheAnsweringStoresHoldings(t *testing.T, ctx context.Context, fixture AsOfReadFixture) {
t.Helper()
if fixture.Resolve == nil {
t.Skip("this backend does not implement as-of reads (Resolve is nil)")
}
if fixture.MintAt == nil {
t.Skip("this backend has no way to mint a version at a controlled accept-time (MintAt is nil)")
}
holds := asOfReadStore(fixture, "tc3-holds-the-lineage")
neverSynced := asOfReadStore(fixture, "tc3-never-synced")
id := fixture.IssuePrefix + "-asof-tc3"
at := time.Now().UTC()
address := asOfReadMint(t, ctx, fixture, holds, id, at)
local, err := fixture.Resolve(ctx, holds, id, AsOfSelector{At: &at})
if err != nil {
t.Fatalf("Resolve on the store that holds the lineage: %v", err)
}
if local.Refusal != nil || local.Address != address {
t.Fatalf("Resolve on the store that holds the lineage = %+v, want it served from that store's own holdings (%s)", local, address)
}
remote, err := fixture.Resolve(ctx, neverSynced, id, AsOfSelector{At: &at})
if err != nil {
t.Fatalf("Resolve on a store that never received this lineage: %v", err)
}
if remote.Refusal == nil {
t.Fatalf("Resolve on a store that never received this lineage = %+v, want a Refusal: an as-of answer is complete for the answering store's own holdings, not a sibling's (TC3)", remote)
}
if remote.Refusal.Restriction != RestrictionUnknown {
t.Errorf("Refusal.Restriction on the never-synced store = %s, want RestrictionUnknown: no lineage knowledge is Unknown, not Gone (FR-06)", remote.Refusal.Restriction)
}
}
// --- fixture helpers -------------------------------------------------------
// asOfReadStore names a storeID namespaced by the fixture's IssuePrefix and
// tag, so cases that need more than one store (e.g. the TC3 local-
// completeness case) get independent ones.
func asOfReadStore(fixture AsOfReadFixture, tag string) string {
return fixture.IssuePrefix + "-asof-store-" + tag
}
// asOfReadMint mints a version for id on store at the given instant via
// fixture.MintAt, fataling the case if minting fails.
func asOfReadMint(t *testing.T, ctx context.Context, fixture AsOfReadFixture, store, id string, at time.Time) Address {
t.Helper()
address, err := fixture.MintAt(ctx, store, id, at)
if err != nil {
t.Fatalf("MintAt(%s, %s, %s): %v", store, id, at, err)
}
return address
}

View file

@ -31,13 +31,8 @@ go_test(
timeout = "long",
srcs = [
"attach_test.go",
"e2e_blocked_flags_test.go",
"e2e_blocked_test.go",
"e2e_cli_test.go",
"e2e_export_test.go",
"e2e_gates_test.go",
"e2e_heartbeat_test.go",
"e2e_link_test.go",
"e2e_list_filters_test.go",
"e2e_list_page_edges_test.go",
"e2e_mol_test.go",
@ -67,7 +62,6 @@ go_test(
"//internal/storage/backends",
"//internal/storage/domain",
"//internal/storage/embeddeddolt",
"//internal/storage/issueops",
"//internal/testutil/bazeltest",
],
)

View file

@ -8,7 +8,6 @@ import (
"net/http"
"os"
"path/filepath"
"slices"
"strings"
"sync"
"testing"
@ -52,12 +51,11 @@ func gateCheckWrites(reqs []string) []string {
}
// TestServedGateCheckOverAwaitTypedGates runs `bd gate check` over HTTP, through
// the reference proxy, against REAL await-typed gates, on a server that
// advertises neither gate token (issues.create.gates, issues.update.gates; the
// profile is masked here, so this holds whatever reference_server.json
// advertises). No create through it carries await_*: the gates are seeded
// straight into the served store before it listens, and every outcome is read
// back from that store:
// the reference proxy, against REAL await-typed gates. The reference server
// advertises neither gate token (issues.create.gates, issues.update.gates), so
// no create through it carries await_*: the gates are seeded straight into the
// served store before it listens, and every outcome is read back from that
// store:
//
// - --dry-run writes nothing;
// - an expired timer closes, a pending one stays open;
@ -143,13 +141,7 @@ func TestServedGateCheckOverAwaitTypedGates(t *testing.T) {
}
})
// The gh:run case pins a server that cannot take an await_id patch, so the
// profile is held without issues.update.gates whatever
// reference_server.json advertises: upgrading the reference profile must
// not turn this case into a different test.
profile := loadReferenceProfile(t)
profile.Capabilities = slices.DeleteFunc(profile.Capabilities, func(c string) bool { return c == "issues.update.gates" })
proxy := newReferenceProxy(t, profile, srv.Addr())
proxy := newReferenceProxy(t, loadReferenceProfile(t), srv.Addr())
reqs := &gateCheckRequestLog{next: proxy}
proxyAddr := startProxy(t, reqs)

View file

@ -142,10 +142,6 @@ func corpusServeConfig(t *testing.T, s storage.DoltStorage) httpapi.Config {
must("BatchGetter")
cfg.LeaseReclaimer, err = s.LeaseReclaimer()
must("LeaseReclaimer")
cfg.Heartbeater, err = s.Heartbeater()
must("Heartbeater")
cfg.BlockedLister, err = s.BlockedLister()
must("BlockedLister")
cfg.Relations, err = s.IssueRelations()
must("IssueRelations")
cfg.Commenter, err = s.Commenter()

View file

@ -96,18 +96,11 @@ files:
{"key": "t-ifa", "id": "e2e-t-ifa", "title": "target ifa", "type": "task", "assignee": "worker", "metadata": {"seeded": "keep"}},
{"key": "t-death", "id": "e2e-t-death", "title": "target death", "type": "task", "assignee": "worker"},
{"key": "t-rc", "id": "e2e-t-rc", "title": "target rc", "type": "task", "assignee": "worker"},
{"key": "t-hb", "id": "e2e-t-hb", "title": "target hb", "type": "task"},
{"key": "t-hb2", "id": "e2e-t-hb2", "title": "target hb2", "type": "task"},
{"key": "t-hb3", "id": "e2e-t-hb3", "title": "target hb3", "type": "task"},
{"key": "t-boot", "id": "e2e-t-boot", "title": "target boot", "type": "task"},
{"key": "t-ro", "id": "e2e-t-ro", "title": "target reopen", "type": "task"},
{"key": "t-dr", "id": "e2e-t-dr", "title": "target dep remove", "type": "task", "deps": [{"target": "t-db"}]},
{"key": "t-dc", "id": "e2e-t-dc", "title": "cascade root", "type": "epic"},
{"key": "t-dc.1", "id": "e2e-t-dc.1", "title": "cascade child", "type": "task", "parent_key": "t-dc"},
{"key": "t-gcr", "id": "e2e-t-gcr", "title": "target gate create", "type": "task"},
{"key": "t-gct", "id": "e2e-t-gct", "title": "target gate check", "type": "task"},
{"key": "t-gw", "id": "e2e-t-gw", "title": "target gate waiter", "type": "gate"},
{"key": "t-gaw", "id": "e2e-t-gaw", "title": "target gate await id", "type": "gate"}
{"key": "t-dc.1", "id": "e2e-t-dc.1", "title": "cascade child", "type": "task", "parent_key": "t-dc"}
]}
- name: bulk-ready-a.json
bulk: {id_prefix: e2e-bra, count: 60, priority: 3, metadata: {gc.routed_to: pool-a}}
@ -308,39 +301,6 @@ shapes:
source: mc skills/pr-review (list --all --id --json --limit)
args: [list, --all, --id, "e2e-r1,e2e-a1", --json, --limit, "0"]
pending: {slice: "SRV-1", reason: "S15b sends --id as listIssues id behind issues.list.ids, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListScopeFiltersOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: gc-polecat-title-contains
source: gascity core formulas/mol-polecat-base.toml (list --title-contains --status a,b,c --json)
args: [list, --title-contains, "Routed", --status, "open,in_progress,blocked", --json]
pending: {slice: "SRV-1", reason: "--title-contains folds onto listIssues title behind issues.list.title, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListScopeFiltersOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: gc-polecat-title-contains-closed-after
source: gascity core formulas/mol-polecat-base.toml (pre-flight 3d, list --title-contains --status closed --closed-after DATE --json)
args: [list, --title-contains, "closed task", --status, closed, --closed-after, "2000-01-01", --json]
pending: {slice: "SRV-1", reason: "needs issues.list.title (--title-contains folds onto listIssues title) and issues.list.filters (closed_after), which the reference server does not advertise, so the client refuses before dialing; remove the mark when reference_server.json is upgraded"}
- id: gc-polecat-closed-after
source: gascity core formulas/mol-polecat-base.toml:267 (list --title-contains --status closed --closed-after --json)
args: [list, --title-contains, "task", --status, closed, --closed-after, "2000-01-01", --json]
compare: ids
pending: {slice: "SRV-1", reason: "needs issues.list.title (--title-contains folds onto listIssues title) and issues.list.filters (closed_after), which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListFilterParityOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: wf-session-cleanup
source: an order cleanup script's closed-session sweep (list --all --include-infra --include-gates --status closed --label --closed-before --updated-before)
args: [list, --json, --all, --include-infra, --include-gates, --status, closed, --label, "lane:a", --closed-before, "2100-01-01T00:00:00Z", --updated-before, "2100-01-01T00:00:00Z", --limit, "0"]
compare: ids
pending: {slice: "SRV-1", reason: "needs issues.list.filters, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListFilterParityOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: list-filter-priority-range
source: bd list --priority-min/--priority-max (listing filter parity)
args: [list, --json, --priority-min, "1", --priority-max, "3", --limit, "0"]
compare: ids
pending: {slice: "SRV-1", reason: "needs issues.list.filters, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListFilterParityOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: list-filter-exclude-type-no-parent
source: bd list --exclude-type --no-parent (listing filter parity)
args: [list, --json, --exclude-type, epic, --no-parent, --limit, "0"]
compare: ids
pending: {slice: "SRV-1", reason: "needs issues.list.filters, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListFilterParityOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: list-filter-updated-after
source: bd list --updated-after (listing filter parity)
args: [list, --json, --updated-after, "2000-01-01", --limit, "0"]
compare: ids
pending: {slice: "SRV-1", reason: "needs issues.list.filters, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_ListFilterParityOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: mc-list-assignee-status
source: mc review summaries (list --assignee --json --limit --status)
args: [list, --assignee, alice, --json, --limit, "10", --status, open]
@ -404,23 +364,7 @@ shapes:
- id: gc-blocked
source: gc bdstore_ready_projection.go fetchReadyProjectionViaBlocked
args: [blocked, --json]
pending: {slice: "SRV-1", reason: "bd blocked dials listBlockedIssues behind blocked.list, which the reference server does not advertise, so the client refuses at its capability preflight (pinned passing against the current server by backend/http TestE2E_BlockedOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: gc-blocked-flags
source: gc bdstore_ready_projection.go readiness door (bd blocked --flags --json, ids on stdin)
args: [blocked, --flags, --json]
stdin: "e2e-mol\ne2e-mol.1\ne2e-mol.2\ne2e-no-such-row\n"
compare: json
pending: {slice: "SRV-1", reason: "bd blocked --flags reads listBlockingAnnotations is_blocked behind dependencies.blocking.isBlocked, which the reference server does not advertise, so the client refuses at its capability preflight (pinned passing against the current server by backend/http TestE2E_BlockedFlagsOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: gc-blocked-flags-raw
source: gc bdstore_ready_projection.go readiness door (the stored is_blocked column, bd blocked --flags --raw --json, ids on stdin)
args: [blocked, --flags, --raw, --json]
stdin: "e2e-mol\ne2e-mol.1\ne2e-mol.2\ne2e-no-such-row\n"
compare: json
pending: {slice: "SRV-1", reason: "bd blocked --flags reads listBlockingAnnotations is_blocked behind dependencies.blocking.isBlocked, which the reference server does not advertise, so the client refuses at its capability preflight (pinned passing against the current server by backend/http TestE2E_BlockedFlagsOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: gc-blocked-parent
source: bd blocked --parent (the molecule-scoped blocked listing)
args: [blocked, --json, --parent, e2e-mol]
pending: {slice: "SRV-1", reason: "bd blocked dials listBlockedIssues behind blocked.list, which the reference server does not advertise, so the client refuses at its capability preflight (pinned passing against the current server by backend/http TestE2E_BlockedOverHTTP); remove the mark when reference_server.json is upgraded"}
pending: {slice: "S18", reason: "bd blocked hits the GetBlockedIssues stub (B3 #10)"}
# ---------------------------------------------------------------- molecules
- id: mc-mol-current
@ -498,8 +442,7 @@ shapes:
source: core pack orders (gate list --all)
args: [gate, list, --all, --json]
# gate check lists the open gates through the same ListGates entry. No
# seeded gate carries an await type (the seed graph carries no gate members;
# mc-gate-check-timer-resolves below creates a real timer gate), so the
# seeded gate carries an await type (no wire create accepts await_*), so the
# typed sweeps find nothing of their type and the untyped one lists the open
# gates and evaluates none: the listing is what these shapes prove served,
# and nothing resolves, escalates (no gt exec) or writes.
@ -767,35 +710,6 @@ shapes:
compare: exit
verify: [[show, --json, e2e-t-rc]]
pending: {slice: "SRV-1", reason: "the reference server does not advertise issues.reclaim (B3 #12), so the client refuses at its capability preflight"}
- id: gc-heartbeat
source: gc formulas/mol-do-work.toml:47 (gc bd heartbeat <id> -> bd heartbeat)
setup: [[update, e2e-t-hb, --claim]]
args: [heartbeat, e2e-t-hb, --json]
verify: [[show, --json, e2e-t-hb]]
pending: {slice: "reference-server-heartbeat", reason: "the reference server does not advertise issues.heartbeat, so the client refuses at its capability preflight; pinned passing by backend/http TestE2E_HeartbeatOverHTTP; remove the mark when reference_server.json is upgraded"}
- id: gc-heartbeat-non-holder
source: gc formulas/mol-do-work.toml:47 (a worker heartbeating a bead another actor holds)
setup: [[update, e2e-t-hb2, --claim, --actor, alice]]
args: [heartbeat, e2e-t-hb2]
expect_exit: 1
expect_stderr: "(?i)claimed by|alice"
compare: exit
pending: {slice: "reference-server-heartbeat", reason: "the reference server does not advertise issues.heartbeat, so the client refuses at its capability preflight; pinned passing by backend/http TestE2E_HeartbeatOverHTTP; remove the mark when reference_server.json is upgraded"}
- id: gc-heartbeat-closed
source: gc formulas/mol-do-work.toml:47 (a worker heartbeating a bead that was closed under it)
setup: [[update, e2e-t-hb3, --claim], [close, e2e-t-hb3]]
args: [heartbeat, e2e-t-hb3]
expect_exit: 1
expect_stderr: "(?i)status closed|is closed"
compare: exit
pending: {slice: "reference-server-heartbeat", reason: "the reference server does not advertise issues.heartbeat, so the client refuses at its capability preflight; pinned passing by backend/http TestE2E_HeartbeatOverHTTP; remove the mark when reference_server.json is upgraded"}
- id: gc-heartbeat-wisp
source: gc formulas/mol-do-work.toml:47 (a heartbeat on a wisp, which is never leased)
args: [heartbeat, e2e-wisp-2]
expect_exit: 1
expect_stderr: "(?i)ephemeral"
compare: exit
pending: {slice: "reference-server-heartbeat", reason: "the reference server does not advertise issues.heartbeat, so the client refuses at its capability preflight; pinned passing by backend/http TestE2E_HeartbeatOverHTTP; remove the mark when reference_server.json is upgraded"}
- id: mc-promote
source: mc mol-normalized-issue-pr-v1 (promote --reason)
args: [promote, e2e-wisp-p, --reason, "keep it"]
@ -850,33 +764,3 @@ shapes:
expect_exit: 1
expect_stderr: 'unknown command "meta"'
compare: exit
# ---------------------------------------------------------------- gates
# The gate writes: create (one createIssue carrying the gate members and the
# blocks edge), a real timer gate resolving under gate check, add-waiter (a
# guarded waiters patch) and update --await-id. A --timeout=1ns timer is
# expired by the time gate check runs, so the resolution is deterministic.
- id: mc-gate-create-timer
source: core formulas / gate-sweep (bd gate create --type=timer --timeout --blocks)
args: [gate, create, --type=timer, --timeout=1ns, --blocks, e2e-t-gcr, --json]
ignore_fields: [id] # each side mints its own gate id
pending: {slice: "SRV-1", reason: "bd gate create sends the gate members on createIssue behind issues.create.gates, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_GatesOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: mc-gate-check-timer-resolves
source: core gate-sweep.sh (gate check --type=timer --escalate) over a real timer gate
setup: [[gate, create, --type=timer, --timeout=1ns, --blocks, e2e-t-gct]]
args: [gate, check, --type=timer, --escalate]
compare: exit
verify: [[ready, --json, --limit, "0"]] # e2e-t-gct is ready on both sides
ignore_fields: [depends_on_id] # its (closed) gate's id is minted per workspace
pending: {slice: "SRV-1", reason: "the setup bd gate create sends the gate members on createIssue behind issues.create.gates, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_GatesOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: mc-gate-add-waiter
source: bd done --phase-complete (gate add-waiter)
args: [gate, add-waiter, e2e-t-gw, "rig/workers/a"]
compare: text
verify: [[show, --json, e2e-t-gw]]
pending: {slice: "SRV-1", reason: "bd gate add-waiter sends waiters on updateIssue behind issues.update.gates, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_GatesOverHTTP); remove the mark when reference_server.json is upgraded"}
- id: mc-update-await-id
source: gate discover / gate check gh:run persist (update --await-id)
args: [update, e2e-t-gaw, --await-id, "12345", --json]
compare: exit
verify: [[show, --json, e2e-t-gaw]]
pending: {slice: "SRV-1", reason: "bd update --await-id sends await_id on updateIssue behind issues.update.gates, which the reference server does not advertise, so the client refuses before dialing (pinned passing against the current server by backend/http TestE2E_GatesOverHTTP); remove the mark when reference_server.json is upgraded"}

View file

@ -1,287 +0,0 @@
//go:build cgo
package bdhttp_test
import (
"context"
"encoding/json"
"errors"
"os/exec"
"reflect"
"sort"
"strings"
"testing"
"github.com/steveyegge/beads/internal/storage/issueops"
)
// runBDStdin is runBD with stdin.
func runBDStdin(t *testing.T, f *remoteRolesFixture, stdin string, args ...string) bdResult {
t.Helper()
cmd := exec.Command(f.bin, args...)
cmd.Dir = f.dir
cmd.Env = minimalBDEnv(f.dir)
cmd.Stdin = strings.NewReader(stdin)
var o, e strings.Builder
cmd.Stdout, cmd.Stderr = &o, &e
err := cmd.Run()
code := 0
var exitErr *exec.ExitError
if errors.As(err, &exitErr) {
code = exitErr.ExitCode()
} else if err != nil {
t.Fatalf("run bd %v: %v", args, err)
}
return bdResult{stdout: o.String(), stderr: e.String(), code: code}
}
type blockedFlagRow struct {
ID string `json:"id"`
IsBlocked bool `json:"is_blocked"`
}
func parseBlockedFlags(t *testing.T, out string) []blockedFlagRow {
t.Helper()
var rows []blockedFlagRow
if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &rows); err != nil {
t.Fatalf("parse bd blocked --flags --json: %v\n%s", err, out)
}
if rows == nil {
t.Fatalf("bd blocked --flags --json printed null, want an array: %s", out)
}
return rows
}
// flagStdin is every id the fixture created, in title order, plus an id that
// names no row, a blank line and a repeat: the omitted, ignored and collapsed
// cases.
func flagStdin(f *remoteRolesFixture) string {
titles := make([]string, 0, len(f.ids))
for title := range f.ids {
titles = append(titles, title)
}
sort.Strings(titles)
var b strings.Builder
for _, title := range titles {
b.WriteString(f.ids[title] + "\n")
}
b.WriteString("\n " + f.ids[titles[0]] + " \ne2e-no-such-row\n")
return b.String()
}
// TestE2E_BlockedFlagsOverHTTP runs `bd blocked --flags --json` (the blocked
// flag per id read from stdin, the readiness column gc projects) through the
// real `bd` binary against an in-process `bd serve` and against a local
// embedded workspace holding the same graph, and requires the same JSON once
// each generated id is mapped to its title. Over HTTP the read is
// listBlockingAnnotations with is_blocked; an older server's handshake is
// refused before the dial, naming dependencies.blocking.isBlocked.
//
// It also pins that this is the FLAG and not the listing: a row whose stored
// flag is set with no nameable blocker reads true here and is absent from
// `bd blocked --json`.
func TestE2E_BlockedFlagsOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
seed := func(f *remoteRolesFixture) {
f.seed()
blocker := f.create("blocker", "-t", "task")
gp := f.create("gate-parent", "-t", "epic")
kid := f.create("gate-kid", "-t", "task")
f.mustRun(nil, "dep", "add", kid, gp, "--type", "parent-child")
f.mustRun(nil, "dep", "add", gp, blocker)
}
t.Run("served equals local", func(t *testing.T) {
addr := startE2EServer(t)
local := newEmbeddedFixture(t, bin)
seed(local)
served := newHTTPFixture(t, bin, addr)
seed(served)
lr := runBDStdin(t, local, flagStdin(local), "blocked", "--flags", "--json")
sr := runBDStdin(t, served, flagStdin(served), "blocked", "--flags", "--json")
if lr.code != 0 || sr.code != 0 {
t.Fatalf("exit local=%d served=%d\nlocal: %s %s\nserved: %s %s", lr.code, sr.code, lr.stdout, lr.stderr, sr.stdout, sr.stderr)
}
normalize := func(f *remoteRolesFixture, rows []blockedFlagRow) []blockedFlagRow {
titleOf := map[string]string{}
for title, id := range f.ids {
titleOf[id] = title
}
out := make([]blockedFlagRow, 0, len(rows))
for _, row := range rows {
if title, ok := titleOf[row.ID]; ok {
row.ID = title
}
out = append(out, row)
}
return out
}
want := normalize(local, parseBlockedFlags(t, lr.stdout))
got := normalize(served, parseBlockedFlags(t, sr.stdout))
if !reflect.DeepEqual(want, got) {
t.Errorf("served bd blocked --flags --json differs from the local command:\nlocal: %v\nserved: %v", want, got)
}
if len(want) != len(local.ids) {
t.Errorf("local answered %d rows for %d ids (the unknown id omitted, the repeat collapsed): %v", len(want), len(local.ids), want)
}
blocked := map[string]bool{}
for _, row := range got {
blocked[row.ID] = row.IsBlocked
}
for title, wantBlocked := range map[string]bool{
"loner": true, "child-x": true, "gate-parent": true, "gate-kid": true,
"blocker": false, "child-b": false, "parent": false,
} {
if blocked[title] != wantBlocked {
t.Errorf("%s is_blocked = %v, want %v (rows %v)", title, blocked[title], wantBlocked, got)
}
}
// Byte-for-byte the same members in the same order.
if strings.Count(lr.stdout, "\n") != strings.Count(sr.stdout, "\n") {
t.Errorf("line counts differ:\nlocal:\n%s\nserved:\n%s", lr.stdout, sr.stdout)
}
// Nothing piped is an empty array.
if r := runBDStdin(t, served, "", "blocked", "--flags", "--json"); r.code != 0 || strings.TrimSpace(r.stdout) != "[]" {
t.Errorf("empty stdin: exit %d stdout %q, want [] and exit 0", r.code, r.stdout)
}
// The listing's filters are refused, not silently ignored.
if r := runBDStdin(t, served, "x\n", "blocked", "--flags", "--json", "--label", "a"); r.code != 1 {
t.Errorf("--flags --label exited %d, want 1: %s", r.code, r.stdout)
}
})
t.Run("the flag, not the listing", func(t *testing.T) {
addr, reference := startE2EServerWithStore(t, e2eProjectID, e2eDatabase)
served := newHTTPFixture(t, bin, addr)
stale := served.create("stale")
if err := reference.RunEventsMaintenanceTx(context.Background(), func(ctx context.Context, tx issueops.DBTX) error {
_, err := tx.ExecContext(ctx, "UPDATE issues SET is_blocked = 1 WHERE id = ?", stale)
return err
}); err != nil {
t.Fatalf("set the stale flag: %v", err)
}
rows := parseBlockedFlags(t, runBDStdin(t, served, stale+"\n", "blocked", "--flags", "--json").stdout)
if len(rows) != 1 || rows[0].ID != stale || !rows[0].IsBlocked {
t.Errorf("--flags for a stale-flagged row = %v, want [{%s true}]", rows, stale)
}
listing := served.mustRun(nil, "blocked", "--json").stdout
if strings.Contains(listing, stale) {
t.Errorf("bd blocked --json lists %s, which has no nameable blocker: %s", stale, listing)
}
})
t.Run("raw is the stored column", func(t *testing.T) {
addr, reference := startE2EServerWithStore(t, e2eProjectID, e2eDatabase)
local := newEmbeddedFixture(t, bin)
seed(local)
served := newHTTPFixture(t, bin, addr)
seed(served)
flagsOf := func(f *remoteRolesFixture, stdin string, args ...string) map[string]bool {
t.Helper()
r := runBDStdin(t, f, stdin, append([]string{"blocked", "--flags", "--json"}, args...)...)
if r.code != 0 {
t.Fatalf("bd blocked --flags --json %v exited %d: %s %s", args, r.code, r.stdout, r.stderr)
}
titleOf := map[string]string{}
for title, id := range f.ids {
titleOf[id] = title
}
out := map[string]bool{}
for _, row := range parseBlockedFlags(t, r.stdout) {
key := row.ID
if title, ok := titleOf[row.ID]; ok {
key = title
}
out[key] = row.IsBlocked
}
return out
}
localRaw := flagsOf(local, flagStdin(local), "--raw")
servedRaw := flagsOf(served, flagStdin(served), "--raw")
if !reflect.DeepEqual(localRaw, servedRaw) {
t.Errorf("served --raw differs from local --raw:\nlocal: %v\nserved: %v", localRaw, servedRaw)
}
lr := runBDStdin(t, local, flagStdin(local), "blocked", "--flags", "--json", "--raw")
sr := runBDStdin(t, served, flagStdin(served), "blocked", "--flags", "--json", "--raw")
if strings.Count(lr.stdout, "\n") != strings.Count(sr.stdout, "\n") {
t.Errorf("--raw line counts differ:\nlocal:\n%s\nserved:\n%s", lr.stdout, sr.stdout)
}
// child-x is blocked ONLY by an unsatisfied external ref: the policy
// flag says blocked, the stored column does not.
decorated := flagsOf(served, flagStdin(served))
if !decorated["child-x"] || servedRaw["child-x"] || localRaw["child-x"] {
t.Errorf("child-x (externally blocked only): --flags %v, --raw served %v local %v; want true, false, false",
decorated["child-x"], servedRaw["child-x"], localRaw["child-x"])
}
// Locally blocked rows read the same either way.
for _, title := range []string{"loner", "gate-parent", "gate-kid", "blocker"} {
if decorated[title] != servedRaw[title] {
t.Errorf("%s: --flags %v, --raw %v; a local blocker is the column", title, decorated[title], servedRaw[title])
}
}
// A stale flag (set, no blocker) is the column, so both read true.
stale := served.create("stale")
if err := reference.RunEventsMaintenanceTx(context.Background(), func(ctx context.Context, tx issueops.DBTX) error {
_, err := tx.ExecContext(ctx, "UPDATE issues SET is_blocked = 1 WHERE id = ?", stale)
return err
}); err != nil {
t.Fatalf("set the stale flag: %v", err)
}
if got := flagsOf(served, stale+"\n", "--raw"); !got["stale"] {
t.Errorf("--raw for the stale-flagged row = %v, want true", got)
}
if got := flagsOf(served, stale+"\n"); !got["stale"] {
t.Errorf("--flags for the stale-flagged row = %v, want true", got)
}
// --raw qualifies --flags only.
if r := runBDStdin(t, served, "", "blocked", "--json", "--raw"); r.code != 1 || !strings.Contains(r.stdout+r.stderr, "--raw") {
t.Errorf("bd blocked --raw without --flags: exit %d %s %s, want exit 1 naming --raw", r.code, r.stdout, r.stderr)
}
// A server that applies the policy answers the decorated flag and the
// wire cannot ask it for the column: --raw is refused there, before
// the annotation read, rather than answered with the policy flag.
proxyAddr, counter := startMaskingProxy(t, addr, func(body map[string]any) {
caps, _ := body["capabilities"].([]any)
body["capabilities"] = append(caps, "policy.external_dependencies")
})
enforced := newHTTPFixture(t, bin, proxyAddr)
counter.reset()
r := runBDStdin(t, enforced, served.ids["child-x"]+"\n", "blocked", "--flags", "--json", "--raw")
if r.code != 1 || !strings.Contains(r.stdout+r.stderr, "policy.external_dependencies") {
t.Errorf("--raw against a policy server: exit %d %s %s, want exit 1 naming the policy token", r.code, r.stdout, r.stderr)
}
for _, p := range counter.snapshot() {
if strings.Contains(p, "/v0/beads/dependencies/blocking") {
t.Errorf("a refused --raw dialed %s", p)
}
}
})
t.Run("older server mask", func(t *testing.T) {
addr := startE2EServer(t)
proxyAddr, counter := startMaskingProxy(t, addr, mcContextMask)
f := newHTTPFixture(t, bin, proxyAddr)
counter.reset()
r := runBDStdin(t, f, "e2e-anything\n", "blocked", "--flags", "--json")
if r.code != 1 {
t.Fatalf("bd blocked --flags against a server without the token exited %d, want 1: %s", r.code, r.stdout)
}
if !strings.Contains(r.stdout+r.stderr, "dependencies.blocking.isBlocked") {
t.Errorf("refusal does not name the missing capability: stdout=%s stderr=%s", r.stdout, r.stderr)
}
for _, p := range counter.snapshot() {
if strings.Contains(p, "/v0/beads/dependencies/blocking") {
t.Errorf("a refused bd blocked --flags dialed %s", p)
}
}
})
}

View file

@ -1,229 +0,0 @@
//go:build cgo
package bdhttp_test
import (
"encoding/json"
"reflect"
"slices"
"strings"
"testing"
)
// TestE2E_BlockedOverHTTP runs `bd blocked --json` (the blocked door gc's
// readiness projection reads) through the real `bd` binary against an
// in-process `bd serve`, and against a local embedded workspace holding the
// same graph.
//
// Over HTTP the CLI takes the store's BlockedLister, which dials
// GET /v0/beads/blocked behind blocked.list. The two answers must be the same
// JSON once the values that cannot agree between two workspaces (each row's
// generated id, and its timestamps) are mapped out: the same rows, the same
// members, the same blockers (local, parent-attributed and external), in the
// same order. Against a server that does not advertise blocked.list (an older
// server's handshake) the client refuses before the dial, naming the token.
func TestE2E_BlockedOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr := startE2EServer(t)
seedBlocked := func(f *remoteRolesFixture) {
f.seed()
// A plain blocks edge, a blocked parent's child attributed to the
// parent, and a labelled blocked row for the filter arms.
blocker := f.create("blocker", "-t", "task", "-p", "1")
gp := f.create("gate-parent", "-t", "epic", "-p", "2")
// Its own priority: rows tied on priority and created_at fall to the
// id order, and ids are generated per workspace, so a tie would order
// the two workspaces differently.
kid := f.create("gate-kid", "-t", "task", "-p", "3")
tagged := f.create("tagged", "-t", "task", "-p", "1", "-l", "lane:a")
// Blocked by nothing but an unsatisfied external ref, as child-x is,
// and labelled: the decorator lists such rows itself, after the label
// query ran, so the filter arms must judge them too.
extTagged := f.create("ext-tagged", "-t", "task", "-p", "4", "-l", "lane:a")
f.mustRun(nil, "dep", "add", kid, gp, "--type", "parent-child")
f.mustRun(nil, "dep", "add", gp, blocker)
f.mustRun(nil, "dep", "add", tagged, blocker)
f.mustRun(nil, "dep", "add", extTagged, "external:other:cap")
}
local := newEmbeddedFixture(t, bin)
seedBlocked(local)
served := newHTTPFixture(t, bin, addr)
seedBlocked(served)
for _, args := range [][]string{
{"blocked", "--json"},
{"blocked", "--json", "--label", "lane:a"},
{"blocked", "--json", "--label-any", "lane:a"},
{"blocked", "--json", "--exclude-label", "lane:a"},
{"blocked", "--json", "--parent", "{gate-parent}"},
{"blocked", "--json", "--label", "no-such-label"},
} {
t.Run(strings.Join(args[1:], " "), func(t *testing.T) {
want := local.mustRun(nil, local.expand(args)...).stdout
got := served.mustRun(nil, served.expand(args)...).stdout
if strings.TrimSpace(want) == "null" || strings.TrimSpace(got) == "null" {
t.Fatalf("bd blocked --json printed null: local=%s served=%s", want, got)
}
if w, g := normalizeBlocked(t, local, want), normalizeBlocked(t, served, got); !reflect.DeepEqual(w, g) {
t.Errorf("served bd blocked --json differs from the local command:\nlocal: %v\nserved: %v", w, g)
}
if w, g := blockedKeyOrder(t, want), blockedKeyOrder(t, got); !reflect.DeepEqual(w, g) {
t.Errorf("served member order %v differs from the local command's %v", g, w)
}
})
}
t.Run("names the external blocker", func(t *testing.T) {
got := normalizeBlocked(t, served, served.mustRun(nil, "blocked", "--json").stdout)
found := false
for _, row := range got {
if row["id"] == "child-x" {
found = reflect.DeepEqual(row["blocked_by"], []any{"external:other:cap"})
}
}
if !found {
t.Errorf("served bd blocked --json does not list child-x blocked by its external ref: %v", got)
}
})
// The arms above compare the two answers, which agree just as well when
// both list a row the filter rules out. These pin which rows each filter
// leaves, the external-only ones (child-x unlabelled, ext-tagged
// labelled) among them.
for _, tc := range []struct {
args []string
want []string // the whole listing, when set
listed, ruled []string
}{
{args: []string{"--label", "lane:a"}, want: []string{"ext-tagged", "tagged"}},
{args: []string{"--label-any", "lane:a"}, want: []string{"ext-tagged", "tagged"}},
{args: []string{"--label", "no-such-label"}, want: []string{}},
{args: []string{"--exclude-label", "lane:a"}, listed: []string{"child-x"}, ruled: []string{"ext-tagged", "tagged"}},
} {
t.Run("filters external-only rows "+strings.Join(tc.args, " "), func(t *testing.T) {
for _, f := range []struct {
name string
f *remoteRolesFixture
}{{"local", local}, {"served", served}} {
got := f.f.titlesOf(f.f.mustRun(nil, append([]string{"blocked", "--json"}, tc.args...)...).stdout)
if tc.want != nil && !slices.Equal(got, tc.want) {
t.Errorf("%s bd blocked %s listed %v, want %v", f.name, strings.Join(tc.args, " "), got, tc.want)
}
for _, title := range tc.listed {
if !slices.Contains(got, title) {
t.Errorf("%s bd blocked %s does not list %s: %v", f.name, strings.Join(tc.args, " "), title, got)
}
}
for _, title := range tc.ruled {
if slices.Contains(got, title) {
t.Errorf("%s bd blocked %s lists %s, which the filter rules out: %v", f.name, strings.Join(tc.args, " "), title, got)
}
}
}
})
}
t.Run("older server mask", func(t *testing.T) {
proxyAddr, counter := startMaskingProxy(t, addr, mcContextMask)
f := newHTTPFixture(t, bin, proxyAddr)
counter.reset()
r := f.run(nil, "blocked", "--json")
if r.code != 1 {
t.Fatalf("bd blocked against a server without blocked.list exited %d, want 1: %s", r.code, r.stdout)
}
if !strings.Contains(r.stdout+r.stderr, "blocked.list") {
t.Errorf("refusal does not name the missing capability: stdout=%s stderr=%s", r.stdout, r.stderr)
}
for _, p := range counter.snapshot() {
if strings.Contains(p, "/v0/beads/blocked") {
t.Errorf("a refused bd blocked dialed %s; the refusal must come before the dial", p)
}
}
})
}
// normalizeBlocked parses `bd blocked --json` and maps out what two
// workspaces cannot share: each id (and each blocker id) becomes the title the
// fixture created it under, and every timestamp member is blanked.
func normalizeBlocked(t *testing.T, f *remoteRolesFixture, out string) []map[string]any {
t.Helper()
var rows []map[string]any
if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &rows); err != nil {
t.Fatalf("parse bd blocked --json: %v\n%s", err, out)
}
titleOf := map[string]string{}
for title, id := range f.ids {
titleOf[id] = title
}
var walk func(key string, v any) any
walk = func(key string, v any) any {
switch v := v.(type) {
case map[string]any:
for k, inner := range v {
v[k] = walk(k, inner)
}
return v
case []any:
for i := range v {
v[i] = walk("", v[i])
}
return v
case string:
if strings.HasSuffix(key, "_at") {
return "<time>"
}
if title, ok := titleOf[v]; ok {
return title
}
}
return v
}
for _, row := range rows {
walk("", row)
}
return rows
}
// blockedKeyOrder is the member order of each row as printed, so the two
// encodings are compared as text, not only as values.
func blockedKeyOrder(t *testing.T, out string) [][]string {
t.Helper()
var rows []json.RawMessage
if err := json.Unmarshal([]byte(strings.TrimSpace(out)), &rows); err != nil {
t.Fatalf("parse bd blocked --json: %v\n%s", err, out)
}
order := make([][]string, 0, len(rows))
for _, raw := range rows {
dec := json.NewDecoder(strings.NewReader(string(raw)))
var keys []string
depth := 0
for {
tok, err := dec.Token()
if err != nil {
break
}
switch v := tok.(type) {
case json.Delim:
if v == '{' || v == '[' {
depth++
} else {
depth--
}
case string:
if depth == 1 {
keys = append(keys, v)
// Skip the value.
var skip json.RawMessage
if err := dec.Decode(&skip); err != nil {
t.Fatalf("decode value of %s: %v", v, err)
}
}
}
}
order = append(order, keys)
}
return order
}

View file

@ -733,15 +733,6 @@ func startE2EServer(t *testing.T) string {
// the one a prior `bd connect` already pinned, to prove the pin is honored
// rather than silently replaced.
func startE2EServerWithIdentity(t *testing.T, projectID, database string) string {
t.Helper()
addr, _ := startE2EServerWithStore(t, projectID, database)
return addr
}
// startE2EServerWithStore is startE2EServerWithIdentity that also hands back
// the reference store the server serves, for a test that must plant or age
// state no wire verb can reach (an aged lease row).
func startE2EServerWithStore(t *testing.T, projectID, database string) (string, *embeddeddolt.EmbeddedDoltStore) {
t.Helper()
beadsDir := t.TempDir()
ctx := context.Background()
@ -770,7 +761,7 @@ func startE2EServerWithStore(t *testing.T, projectID, database string) (string,
t.Error("the in-process server did not shut down")
}
})
return srv.Addr(), reference
return srv.Addr()
}
func e2eServeConfig(t *testing.T, s storage.DoltStorage, projectID, database string) httpapi.Config {
@ -812,10 +803,6 @@ func e2eServeConfig(t *testing.T, s storage.DoltStorage, projectID, database str
fail("BatchGetter")
cfg.LeaseReclaimer, err = s.LeaseReclaimer()
fail("LeaseReclaimer")
cfg.Heartbeater, err = s.Heartbeater()
fail("Heartbeater")
cfg.BlockedLister, err = s.BlockedLister()
fail("BlockedLister")
cfg.Relations, err = s.IssueRelations()
fail("IssueRelations")
cfg.Commenter, err = s.Commenter()

View file

@ -1,315 +0,0 @@
//go:build cgo
package bdhttp_test
import (
"encoding/json"
"fmt"
"net/http"
"os"
"path/filepath"
"slices"
"strings"
"sync"
"testing"
"time"
)
// gateTokens are the two behavior tokens the gate commands depend on:
// issues.create.gates for a create carrying gate members (bd gate create),
// issues.update.gates for an await_id or waiters patch (bd gate add-waiter,
// bd gate discover, gate check's gh:run persist, bd update --await-id).
var gateTokens = []string{"issues.create.gates", "issues.update.gates"}
// withoutGateTokens rewrites the handshake into a server that predates the
// gate members: the live capability list minus the two gate tokens.
func withoutGateTokens(body map[string]any) {
caps, _ := body["capabilities"].([]any)
kept := make([]any, 0, len(caps))
for _, c := range caps {
if s, _ := c.(string); slices.Contains(gateTokens, s) {
continue
}
kept = append(kept, c)
}
body["capabilities"] = kept
}
// gateShow is the subset of `bd show --json` the gate cases read.
type gateShow struct {
ID string `json:"id"`
Status string `json:"status"`
IssueType string `json:"issue_type"`
AwaitType string `json:"await_type"`
AwaitID string `json:"await_id"`
Timeout int64 `json:"timeout"`
Waiters []string `json:"waiters"`
}
func showGate(t *testing.T, f *remoteRolesFixture, id string) gateShow {
t.Helper()
out := strings.TrimSpace(f.mustRun(nil, "show", id, "--json").stdout)
var rows []gateShow
if err := json.Unmarshal([]byte(out), &rows); err != nil {
var one gateShow
if err1 := json.Unmarshal([]byte(out), &one); err1 != nil {
t.Fatalf("parse bd show --json: %v\n%s", err, out)
}
return one
}
if len(rows) == 0 {
t.Fatalf("bd show %s --json returned no row", id)
}
return rows[0]
}
func readyIDs(t *testing.T, f *remoteRolesFixture) map[string]bool {
t.Helper()
ids := map[string]bool{}
for _, row := range jsonRows(t, f.mustRun(nil, "ready", "--json", "--limit", "0").stdout) {
if id, ok := row["id"].(string); ok {
ids[id] = true
}
}
return ids
}
func writesOf(paths []string) []string {
var writes []string
for _, p := range paths {
if !strings.HasPrefix(p, http.MethodGet+" ") {
writes = append(writes, p)
}
}
return writes
}
// TestE2E_GatesOverHTTP runs the gate commands through the real `bd` binary
// against an in-process `bd serve`.
//
// Against a server that advertises the gate tokens:
// - `bd gate create` is ONE createIssue carrying the gate members and the
// blocks edge (timer, gh:run and bead gates), and the blocked issue
// leaves the ready set;
// - `bd gate check --type=timer` closes an expired timer gate and the
// blocked issue becomes ready;
// - `bd gate add-waiter` registers a waiter once (the repeat writes nothing);
// - `bd update --await-id` sets await_id.
//
// Against a server that does not advertise them, each command is refused
// before any write, naming the token it needs, and nothing changes.
func TestE2E_GatesOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr := startE2EServer(t)
proxyAddr, counter := startCountingProxy(t, addr)
f := newHTTPFixture(t, bin, proxyAddr)
var waiterGate string
t.Run("advertised", func(t *testing.T) {
timerTarget := f.create("timer target")
counter.reset()
created := f.mustRun(nil, "gate", "create", "--type=timer", "--timeout=1ns", "--blocks", timerTarget, "--json")
if w := writesOf(counter.snapshot()); !slices.Equal(w, []string{"POST /v0/beads/issues"}) {
t.Errorf("gate create wrote %v, want exactly one createIssue", w)
}
timerGate := firstJSONField(t, created.stdout, "id")
if g := showGate(t, f, timerGate); g.IssueType != "gate" || g.AwaitType != "timer" || g.Timeout != 1 || g.Status != "open" {
t.Errorf("timer gate reads back %+v, want an open timer gate with a 1ns timeout", g)
}
if readyIDs(t, f)[timerTarget] {
t.Errorf("%s is ready while its gate is open", timerTarget)
}
time.Sleep(10 * time.Millisecond)
r := f.mustRun(nil, "gate", "check", "--type=timer", "--escalate")
if !strings.Contains(r.stdout, "1 resolved") {
t.Errorf("gate check --type=timer = %q, want one resolved gate", r.stdout)
}
if g := showGate(t, f, timerGate); g.Status != "closed" {
t.Errorf("expired timer gate %s is %s after gate check, want closed", timerGate, g.Status)
}
if !readyIDs(t, f)[timerTarget] {
t.Errorf("%s is not ready after its timer gate resolved", timerTarget)
}
runTarget := f.create("run target")
runGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--repo=owner/repo", "--blocks", runTarget, "--json").stdout, "id")
if g := showGate(t, f, runGate); g.AwaitType != "gh:run" || g.AwaitID != "ci-wf" {
t.Errorf("gh:run gate reads back %+v, want await gh:run ci-wf", g)
}
awaited := f.create("awaited bead")
beadTarget := f.create("bead target")
beadGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=bead", "--await-id", awaited, "--blocks", beadTarget, "--json").stdout, "id")
if g := showGate(t, f, beadGate); g.AwaitType != "bead" || g.AwaitID != awaited {
t.Errorf("bead gate reads back %+v, want await bead %s", g, awaited)
}
waiterGate = beadGate
counter.reset()
r = f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/a")
if !strings.Contains(r.stdout, "Added waiter to gate "+beadGate+": rig/workers/a") {
t.Errorf("add-waiter output = %q", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 1 || !strings.HasPrefix(w[0], "PATCH /v0/beads/issues/") {
t.Errorf("add-waiter wrote %v, want one updateIssue", w)
}
counter.reset()
r = f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/a")
if !strings.Contains(r.stdout, "Waiter already registered on gate "+beadGate) {
t.Errorf("repeat add-waiter output = %q", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 0 {
t.Errorf("a repeat add-waiter wrote %v", w)
}
f.mustRun(nil, "gate", "add-waiter", beadGate, "rig/workers/b")
if g := showGate(t, f, beadGate); !slices.Equal(g.Waiters, []string{"rig/workers/a", "rig/workers/b"}) {
t.Errorf("waiters = %v, want [rig/workers/a rig/workers/b]", g.Waiters)
}
f.mustRun(nil, "update", runGate, "--await-id", "12345", "--json")
if g := showGate(t, f, runGate); g.AwaitID != "12345" {
t.Errorf("await_id after update --await-id = %q, want 12345", g.AwaitID)
}
})
// A convoy registering on one gate at once: every adder must exit 0 and
// every waiter must be on the gate. Each round of simultaneous guarded
// writes has one winner, so this pins the retry backoff, not just the
// compare-and-set.
t.Run("concurrent add-waiter", func(t *testing.T) {
const adders = 10
target := f.create("convoy target")
gate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--blocks", target, "--json").stdout, "id")
results := make([]bdResult, adders+1)
var wg sync.WaitGroup
start := make(chan struct{})
for i := 0; i <= adders; i++ {
waiter := fmt.Sprintf("rig/workers/c%d", i%adders) // the last one repeats c0
wg.Add(1)
go func(i int) {
defer wg.Done()
<-start
results[i] = f.run(nil, "gate", "add-waiter", gate, waiter)
}(i)
}
close(start)
wg.Wait()
for i, r := range results {
if r.code != 0 {
t.Errorf("adder %d exited %d: %s", i, r.code, r.stderr)
}
}
got := showGate(t, f, gate).Waiters
slices.Sort(got)
var want []string
for i := 0; i < adders; i++ {
want = append(want, fmt.Sprintf("rig/workers/c%d", i))
}
slices.Sort(want)
if !slices.Equal(got, want) {
t.Errorf("waiters after %d concurrent adders = %v, want each exactly once: %v", adders+1, got, want)
}
})
// gate discover over HTTP: a fake gh answers the run listing, and the
// discovered run ID is recorded through updateIssue (issues.update.gates).
binDir := t.TempDir()
gh := `#!/bin/sh
case "$1 $2" in
"run list") echo '[{"databaseId":4242,"name":"ci-wf","status":"in_progress","conclusion":"","createdAt":"'"$(date -u +%Y-%m-%dT%H:%M:%SZ)"'","workflowName":"ci-wf","headBranch":"main"}]' ;;
*) echo "unexpected gh $*" >&2; exit 3 ;;
esac
`
if err := os.WriteFile(filepath.Join(binDir, "gh"), []byte(gh), 0o755); err != nil {
t.Fatalf("write fake gh: %v", err)
}
ghEnv := []string{"PATH=" + binDir + string(os.PathListSeparator) + os.Getenv("PATH")}
t.Run("discover", func(t *testing.T) {
target := f.create("discover target")
gate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--blocks", target, "--json").stdout, "id")
counter.reset()
r := f.run(ghEnv, "gate", "discover")
if r.code != 0 {
t.Fatalf("gate discover exited %d: %s %s", r.code, r.stdout, r.stderr)
}
if !strings.Contains(r.stdout, "Updated 1 gate(s)") {
t.Errorf("gate discover output = %q, want one updated gate", r.stdout)
}
if w := writesOf(counter.snapshot()); len(w) != 1 || !strings.HasPrefix(w[0], "PATCH /v0/beads/issues/") {
t.Errorf("gate discover wrote %v, want one updateIssue", w)
}
if g := showGate(t, f, gate); g.AwaitID != "4242" {
t.Errorf("await_id after discover = %q, want 4242", g.AwaitID)
}
})
t.Run("refused without the tokens", func(t *testing.T) {
if waiterGate == "" {
t.Skip("the advertised case created no gate")
}
maskedAddr, maskedCounter := startMaskingProxy(t, addr, withoutGateTokens)
m := newHTTPFixture(t, bin, maskedAddr)
target := m.create("masked target")
before := showGate(t, f, waiterGate)
cases := []struct {
name string
args []string
token string
}{
{"gate create", []string{"gate", "create", "--type=timer", "--timeout=1h", "--blocks", target}, "issues.create.gates"},
{"gate create human", []string{"gate", "create", "--blocks", target}, "issues.create.gates"},
{"gate add-waiter", []string{"gate", "add-waiter", waiterGate, "rig/workers/c"}, "issues.update.gates"},
{"update --await-id", []string{"update", waiterGate, "--await-id", "999"}, "issues.update.gates"},
}
for _, tc := range cases {
maskedCounter.reset()
r := m.run(nil, tc.args...)
if r.code == 0 {
t.Errorf("%s against a server without %s exited 0: %s", tc.name, tc.token, r.stdout)
}
if !strings.Contains(r.stderr, tc.token) {
t.Errorf("%s refusal does not name %s: %s", tc.name, tc.token, r.stderr)
}
if w := writesOf(maskedCounter.snapshot()); len(w) != 0 {
t.Errorf("a refused %s wrote %v; the refusal must come before any write", tc.name, w)
}
}
// gate discover finds the run but cannot record it: the gate's error
// names the token, nothing is written, and the command fails rather
// than reporting the gate as updated.
runTarget := f.create("masked discover target")
runGate := firstJSONField(t, f.mustRun(nil, "gate", "create", "--type=gh:run", "--await-id=ci-wf", "--blocks", runTarget, "--json").stdout, "id")
maskedCounter.reset()
r := m.run(ghEnv, "gate", "discover")
if r.code == 0 {
t.Errorf("gate discover against a server without issues.update.gates exited 0: %s", r.stdout)
}
if !strings.Contains(r.stderr, "issues.update.gates") || !strings.Contains(r.stderr, runGate) {
t.Errorf("gate discover refusal does not name the gate and issues.update.gates: %s", r.stderr)
}
if strings.Contains(r.stdout, "Updated 1") {
t.Errorf("gate discover reported the refused gate as updated: %s", r.stdout)
}
if w := writesOf(maskedCounter.snapshot()); len(w) != 0 {
t.Errorf("a refused gate discover wrote %v", w)
}
if g := showGate(t, f, runGate); g.AwaitID != "ci-wf" {
t.Errorf("await_id after a refused discover = %q, want ci-wf untouched", g.AwaitID)
}
if !readyIDs(t, m)[target] {
t.Errorf("%s left the ready set though every gate create was refused", target)
}
after := showGate(t, f, waiterGate)
if after.AwaitID != before.AwaitID || !slices.Equal(after.Waiters, before.Waiters) {
t.Errorf("refused writes changed the gate: before %+v after %+v", before, after)
}
})
}

View file

@ -1,185 +0,0 @@
//go:build cgo
package bdhttp_test
import (
"context"
"encoding/json"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/storage/issueops"
)
// TestE2E_HeartbeatOverHTTP runs `bd heartbeat <id>` — the keepalive gc's
// mol-do-work formula issues every ~90s (`gc bd heartbeat`, corpus shapes
// gc-heartbeat*) — through the real `bd` binary against an in-process `bd
// serve`.
//
// The CLI takes the store's Heartbeater, which over HTTP dials POST
// /v0/beads/issues/{id}:heartbeat. What a worker relies on is pinned here end
// to end: exit 0 and the {"id","status":"heartbeat","owner"} shape for the
// holder, with the row's revision and updated_at UNCHANGED (the heartbeat
// writes only the lease, so the holder's guarded writes keep their token);
// exit 1 for a foreign holder (whose lease stays untouched), a closed issue, a
// wisp and an unclaimed issue, each saying which. Against a server that does
// not advertise issues.heartbeat (an older server's handshake shape) the
// client refuses BEFORE the dial, naming the token, and never falls back.
func TestE2E_HeartbeatOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr, reference := startE2EServerWithStore(t, e2eProjectID, e2eDatabase)
leaseRow := func(id string) string {
t.Helper()
var row string
if err := reference.RunEventsMaintenanceTx(context.Background(), func(ctx context.Context, tx issueops.DBTX) error {
return tx.QueryRowContext(ctx,
"SELECT CONCAT(holder, '|', CAST(lease_expires_at AS CHAR), '|', CAST(heartbeat_at AS CHAR)) FROM leases WHERE issue_id = ?", id,
).Scan(&row)
}); err != nil {
t.Fatalf("read the lease row on %s: %v", id, err)
}
return row
}
ageLease := func(id string) {
t.Helper()
aged := time.Now().UTC().Add(-time.Minute).Truncate(time.Second)
if err := reference.RunEventsMaintenanceTx(context.Background(), func(ctx context.Context, tx issueops.DBTX) error {
_, err := tx.ExecContext(ctx, "UPDATE leases SET lease_expires_at = ?, heartbeat_at = ? WHERE issue_id = ?", aged, aged, id)
return err
}); err != nil {
t.Fatalf("age the lease on %s: %v", id, err)
}
}
heartbeatPosts := func(paths []string) int {
n := 0
for _, p := range paths {
if strings.HasPrefix(p, "POST ") && strings.HasSuffix(p, ":heartbeat") {
n++
}
}
return n
}
t.Run("advertised", func(t *testing.T) {
proxyAddr, counter := startCountingProxy(t, addr)
f := newHTTPFixture(t, bin, proxyAddr)
id := f.create("heartbeat target")
f.mustRun(nil, "update", id, "--claim", "--actor", "worker-7")
before := f.mustRun(nil, "show", id, "--json").stdout
revision := firstJSONField(t, before, "revision")
if revision == "" {
t.Fatalf("bd show --json reported no revision: %s", before)
}
updatedAt := firstJSONField(t, before, "updated_at")
counter.reset()
r := f.mustRun(nil, "heartbeat", id, "--actor", "worker-7", "--json")
var out map[string]any
if err := json.Unmarshal([]byte(strings.TrimSpace(r.stdout)), &out); err != nil {
t.Fatalf("parse bd heartbeat --json: %v\n%s", err, r.stdout)
}
if out["id"] != id || out["status"] != "heartbeat" || out["owner"] != "worker-7" {
t.Errorf("bd heartbeat --json = %v, want {id: %s, status: heartbeat, owner: worker-7}", out, id)
}
if n := heartbeatPosts(counter.snapshot()); n != 1 {
t.Errorf("bd heartbeat sent %d :heartbeat requests, want exactly one: %v", n, counter.snapshot())
}
for _, p := range counter.snapshot() {
if strings.HasPrefix(p, "PATCH ") || (strings.HasPrefix(p, "POST ") && !strings.HasSuffix(p, ":heartbeat")) {
t.Errorf("bd heartbeat sent %s; a heartbeat writes nothing but the lease", p)
}
}
after := f.mustRun(nil, "show", id, "--json").stdout
if got := firstJSONField(t, after, "revision"); got != revision {
t.Errorf("revision moved across a heartbeat: %s -> %s; a guarded write against the pre-heartbeat token would now fail", revision, got)
}
if got := firstJSONField(t, after, "updated_at"); got != updatedAt {
t.Errorf("updated_at moved across a heartbeat: %s -> %s", updatedAt, got)
}
// The holder's guarded write with the pre-heartbeat token still lands.
f.mustRun(nil, "update", id, "--notes", "still mine", "--if-revision", revision, "--actor", "worker-7")
// A second heartbeat is fine: it only moves the expiry later.
f.mustRun(nil, "heartbeat", id, "--actor", "worker-7")
})
t.Run("refusals", func(t *testing.T) {
f := newHTTPFixture(t, bin, addr)
foreign := f.create("held by alice")
f.mustRun(nil, "update", foreign, "--claim", "--actor", "alice")
// Aged first, so a heartbeat that ignored the holder fence would
// really change the row rather than rewrite the claim's own second.
ageLease(foreign)
held := leaseRow(foreign)
r := f.run(nil, "heartbeat", foreign, "--actor", "bob")
if r.code != 1 || !strings.Contains(r.stderr, "claimed by alice") {
t.Errorf("heartbeat by a non-holder: exit %d stderr=%s, want exit 1 naming the holder", r.code, r.stderr)
}
if got := leaseRow(foreign); got != held {
t.Errorf("a refused heartbeat by a non-holder moved alice's lease: %s -> %s", held, got)
}
// Each lease_not_held names the one state it found, and no other.
says := func(what, stderr, want string, not ...string) {
t.Helper()
if !strings.Contains(stderr, want) {
t.Errorf("heartbeat on %s: stderr=%s, want it to say %q", what, stderr, want)
}
for _, n := range not {
if strings.Contains(stderr, n) {
t.Errorf("heartbeat on %s: stderr=%s says %q, which is not the state it found", what, stderr, n)
}
}
}
closed := f.create("closed under its worker")
f.mustRun(nil, "update", closed, "--claim", "--actor", "worker-7")
f.mustRun(nil, "close", closed, "--actor", "worker-7")
r = f.run(nil, "heartbeat", closed, "--actor", "worker-7")
if r.code != 1 {
t.Errorf("heartbeat on a closed issue exited %d, want 1: %s", r.code, r.stderr)
}
says("a closed issue", r.stderr, "is closed", "ephemeral", "not claimed")
wisp := f.create("a wisp is never leased", "--ephemeral")
r = f.run(nil, "heartbeat", wisp, "--actor", "worker-7")
if r.code != 1 {
t.Errorf("heartbeat on a wisp exited %d, want 1: %s", r.code, r.stderr)
}
says("a wisp", r.stderr, "ephemeral wisp", "closed", "not claimed")
unclaimed := f.create("never claimed")
r = f.run(nil, "heartbeat", unclaimed, "--actor", "worker-7")
if r.code != 1 {
t.Errorf("heartbeat on an unclaimed issue exited %d, want 1: %s", r.code, r.stderr)
}
says("an unclaimed issue", r.stderr, "not claimed", "closed", "ephemeral")
})
t.Run("older server mask", func(t *testing.T) {
proxyAddr, counter := startMaskingProxy(t, addr, mcContextMask)
f := newHTTPFixture(t, bin, proxyAddr)
id := f.create("an old server cannot refresh this lease")
f.mustRun(nil, "update", id, "--claim", "--actor", "worker-7")
counter.reset()
r := f.run(nil, "heartbeat", id, "--actor", "worker-7")
if r.code != 1 {
t.Fatalf("bd heartbeat against a server without issues.heartbeat exited %d, want 1: %s", r.code, r.stdout)
}
if !strings.Contains(r.stderr, "issues.heartbeat") {
t.Errorf("refusal does not name the missing capability: %s", r.stderr)
}
for _, p := range counter.snapshot() {
if !strings.HasPrefix(p, "GET ") {
t.Errorf("a refused heartbeat sent %s; the refusal must come before any write", p)
}
}
})
}

View file

@ -1,137 +0,0 @@
//go:build cgo
package bdhttp_test
import (
"encoding/json"
"strings"
"testing"
)
// TestE2E_LinkOverHTTP runs `bd link` through the real `bd` binary against an
// in-process `bd serve`.
//
// bd link writes through the DependencyEditor role (one addDependencies
// request), so it is served over http for any type a workspace spells, well-
// known or not: the server takes any 1-32 character type. Its own checks —
// a non-empty type of at most 32 characters — refuse before anything is
// written, and an edge that already exists with another type reports the
// typed conflict.
func TestE2E_LinkOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr := startE2EServer(t)
proxyAddr, counter := startCountingProxy(t, addr)
f := newHTTPFixture(t, bin, proxyAddr)
t.Run("custom types are served", func(t *testing.T) {
for _, depType := range []string{"owned-by", "ships-in", "available-in", "excluded-from", "advances", "launches", "blocks"} {
from := f.create("link source " + depType)
to := f.create("link target " + depType)
counter.reset()
r := f.mustRun(nil, "link", from, to, "--type", depType, "--json")
var out map[string]any
if err := json.Unmarshal([]byte(strings.TrimSpace(r.stdout)), &out); err != nil {
t.Fatalf("bd link --json: %v\n%s", err, r.stdout)
}
if out["status"] != "added" || out["issue_id"] != from || out["depends_on_id"] != to || out["type"] != depType {
t.Errorf("bd link --type %s --json = %v, want added %s -> %s", depType, out, from, to)
}
adds := 0
for _, p := range counter.snapshot() {
if p == "POST /v0/beads/dependencies:add" {
adds++
}
}
if adds != 1 {
t.Errorf("bd link --type %s sent %d addDependencies requests, want exactly one: %v", depType, adds, counter.snapshot())
}
list := f.mustRun(nil, "dep", "list", from, "--json").stdout
if !depListHas(t, list, to, depType) {
t.Errorf("bd dep list %s does not show the %s edge to %s: %s", from, depType, to, list)
}
}
})
t.Run("text output names both issues", func(t *testing.T) {
from := f.create("text link source")
to := f.create("text link target")
r := f.mustRun(nil, "link", from, to, "--type", "owned-by")
if !strings.Contains(r.stdout, "Linked:") || !strings.Contains(r.stdout, "text link source") ||
!strings.Contains(r.stdout, "text link target") || !strings.Contains(r.stdout, "(owned-by)") {
t.Errorf("bd link output = %q, want the Linked line with both titles and the type", r.stdout)
}
})
t.Run("invalid types refuse before any write", func(t *testing.T) {
from := f.create("invalid link source")
to := f.create("invalid link target")
for _, depType := range []string{"", strings.Repeat("x", 33)} {
counter.reset()
r := f.run(nil, "link", from, to, "--type", depType)
if r.code == 0 {
t.Fatalf("bd link --type %q exited 0: %s", depType, r.stdout)
}
if !strings.Contains(r.stderr, "invalid dependency type") {
t.Errorf("bd link --type %q stderr = %s, want the invalid-type refusal", depType, r.stderr)
}
for _, p := range counter.snapshot() {
if !strings.HasPrefix(p, "GET ") {
t.Errorf("bd link --type %q wrote %s; the refusal must come before any write", depType, p)
}
}
}
if list := f.mustRun(nil, "dep", "list", from, "--json").stdout; depListHas(t, list, to, "") {
t.Errorf("a refused link left an edge %s -> %s: %s", from, to, list)
}
})
t.Run("an edge of another type is a typed conflict", func(t *testing.T) {
from := f.create("conflict source")
to := f.create("conflict target")
f.mustRun(nil, "link", from, to, "--type", "owned-by")
r := f.run(nil, "link", from, to, "--type", "ships-in")
if r.code == 0 {
t.Fatalf("bd link over an existing owned-by edge with ships-in exited 0: %s", r.stdout)
}
// The server answers the role's typed conflict as 409
// dependency_exists, which the client surfaces verbatim.
if !strings.Contains(r.stderr, "dependency_exists") || !strings.Contains(r.stderr, "different type") {
t.Errorf("conflict stderr = %s, want the typed dependency_exists conflict", r.stderr)
}
list := f.mustRun(nil, "dep", "list", from, "--json").stdout
if !depListHas(t, list, to, "owned-by") || depListHas(t, list, to, "ships-in") {
t.Errorf("the conflicting link changed the edge: %s", list)
}
// Re-asserting the same edge is idempotent.
f.mustRun(nil, "link", from, to, "--type", "owned-by")
})
}
// depListHas reports whether `bd dep list --json` lists an edge to target of
// depType (any type when depType is empty).
func depListHas(t *testing.T, out, target, depType string) bool {
t.Helper()
trimmed := strings.TrimSpace(out)
if trimmed == "" || trimmed == "null" {
return false
}
var rows []map[string]any
if err := json.Unmarshal([]byte(trimmed), &rows); err != nil {
t.Fatalf("parse bd dep list --json: %v\n%s", err, out)
}
for _, row := range rows {
if row["id"] != target && row["depends_on_id"] != target {
continue
}
if depType == "" {
return true
}
if row["dependency_type"] == depType || row["type"] == depType {
return true
}
}
return false
}

View file

@ -8,16 +8,12 @@ import (
"testing"
)
// listScopeShapes are the tokened `bd list` shapes, with the token each needs
// and the titles each must answer on the scope seed. Five are corpus shapes
// (backend/http/corpus/testdata/corpus.yaml) and one pins the title fold:
// listScopeShapes are the four maintainer-city `bd list` shapes S15b serves,
// one per corpus shape (backend/http/corpus/testdata/corpus.yaml), with the
// token each needs and the titles each must answer on the scope seed:
// - gc-list-on-boot: gc's default on_boot hook, run on every agent boot;
// - gc-list-on-boot-workflow: the same recovery, workflow lane;
// - mc-list-title: the PR-intake formula's `--title "$SUBJECT"`;
// - gc-polecat-title-contains: the polecat pre-flight's open-bead lookup,
// `--title-contains "$SYMPTOM_KEY"`, folded onto `title`;
// - title-and-title-contains-equal (not a corpus shape): one value under
// both title flags is one `title`;
// - mc-list-id: the pr-review skill's `--id <ids>`.
var listScopeShapes = []struct {
corpusID string
@ -35,15 +31,6 @@ var listScopeShapes = []struct {
{"mc-list-title",
[]string{"list", "--all", "--include-infra", "--json", "--limit", "10", "--title", "CHILD-A"},
"issues.list.title", []string{"child-a"}},
// --title-contains folds onto the same `title` parameter: case-insensitive
// substring, and the status set leaves the closed child-c out.
{"gc-polecat-title-contains",
[]string{"list", "--title-contains", "CHILD", "--status", "open,in_progress,blocked", "--json"},
"issues.list.title", []string{"child-a", "child-b", "child-x"}},
// The same value under both flags is one predicate.
{"title-and-title-contains-equal",
[]string{"list", "--all", "--title", "child-a", "--title-contains", "child-a", "--json"},
"issues.list.title", []string{"child-a"}},
// A closed id in the set is listed under --all; ids outside it are not.
{"mc-list-id",
[]string{"list", "--all", "--id", "{child-c},{loner}", "--json", "--limit", "0"},
@ -124,131 +111,3 @@ func TestE2E_ListScopeFiltersOverHTTP(t *testing.T) {
}
})
}
// listFilterShapes are the `bd list` shapes that ride the listing filters
// behind issues.list.filters, each with the titles it must answer on the seed
// plus seedListFilters. Five are corpus shapes and one pins the title pair the
// fold leaves:
// - wf-session-cleanup: the session-cleanup sweep's closed-and-stale scan;
// - gc-polecat-closed-after: the polecat formula's "has the fix landed"
// check (title substring, closed after a cutoff);
// - list-filter-priority-range, list-filter-exclude-type-no-parent and
// list-filter-updated-after: one representative per remaining family;
// - title-and-title-contains-differ (not a corpus shape): a `--title` and a
// `--title-contains` that differ ride `title` and `title_contains`
// together, and the server applies both.
var listFilterShapes = []struct {
corpusID string
args []string
want []string
}{
{"wf-session-cleanup",
[]string{"list", "--json", "--all", "--include-infra", "--include-gates", "--status", "closed", "--label", "lane:a",
"--closed-before", "2100-01-01T00:00:00Z", "--updated-before", "2100-01-01T00:00:00Z", "--limit", "0"},
[]string{"lane task closed"}},
{"gc-polecat-closed-after",
[]string{"list", "--title-contains", "task", "--status", "closed", "--closed-after", "2000-01-01", "--json"},
[]string{"lane task closed", "other lane task closed"}},
{"list-filter-priority-range",
[]string{"list", "--json", "--priority-min", "1", "--priority-max", "3", "--limit", "0"},
[]string{"child-a", "child-b", "loner", "open task p2", "parent", "tmpl"}},
{"list-filter-exclude-type-no-parent",
[]string{"list", "--json", "--exclude-type", "epic", "--no-parent", "--limit", "0"},
[]string{"loner", "open task p2", "p4 row", "tmpl"}},
{"list-filter-updated-after",
[]string{"list", "--json", "--updated-after", "2000-01-01", "--limit", "0"},
[]string{"child-a", "child-b", "child-x", "loner", "open task p2", "p4 row", "parent", "tmpl"}},
// Either substring alone answers more: "child" every child, "a" the
// lane tasks, parent and open task p2 too.
{"title-and-title-contains-differ",
[]string{"list", "--all", "--title", "child", "--title-contains", "a", "--json"},
[]string{"child-a"}},
}
// seedListFilters adds the rows the filter shapes split: two closed tasks on
// different lanes (the label keeps one out of the session-cleanup scan, the
// title substring keeps child-c out of the polecat check), a P4 row the
// priority range leaves out, and an open P2 task beside it.
func (f *remoteRolesFixture) seedListFilters() {
f.t.Helper()
a := f.create("lane task closed", "-t", "task", "-l", "lane:a")
b := f.create("other lane task closed", "-t", "task", "-l", "lane:b")
f.mustRun(nil, "close", a, "--reason", "done")
f.mustRun(nil, "close", b, "--reason", "done")
f.create("p4 row", "-t", "task", "-p", "4")
f.create("open task p2", "-t", "task", "-p", "2")
}
// withoutListFilters rewrites the handshake into a server that is current in
// every respect but one: it does not advertise issues.list.filters.
func withoutListFilters(body map[string]any) {
caps, _ := body["capabilities"].([]any)
kept := make([]any, 0, len(caps))
for _, c := range caps {
if c != "issues.list.filters" {
kept = append(kept, c)
}
}
body["capabilities"] = kept
}
// TestE2E_ListFilterParityOverHTTP: `bd list`'s time bounds and every other
// filter the listing refused over http now ride listIssues behind the one
// behavior token issues.list.filters, applied by the same Reader role a local
// `bd list` reads through. Each shape must answer the rows an embedded
// workspace answers, and exactly the rows it names.
//
// Against a server that does not advertise the token each shape refuses
// BEFORE dialing listIssues, naming the token, rather than answering a wider
// listing.
func TestE2E_ListFilterParityOverHTTP(t *testing.T) {
skipUnlessEmbeddedDolt(t)
bin := buildBD(t)
addr := startE2EServer(t)
remote := newHTTPFixture(t, bin, addr)
local := newEmbeddedFixture(t, bin)
for _, f := range []*remoteRolesFixture{remote, local} {
f.seed()
f.seedListFilters()
}
for _, shape := range listFilterShapes {
t.Run(shape.corpusID, func(t *testing.T) {
r := remote.run(nil, shape.args...)
if r.code != 0 {
t.Fatalf("http: bd %s failed (exit %d): stderr=%s", strings.Join(shape.args, " "), r.code, r.stderr)
}
l := local.mustRun(nil, shape.args...)
got, want := remote.titlesOf(r.stdout), local.titlesOf(l.stdout)
if !slices.Equal(got, want) {
t.Errorf("http rows %v, embedded rows %v", got, want)
}
if !slices.Equal(got, shape.want) {
t.Errorf("http rows %v, want exactly %v", got, shape.want)
}
})
}
t.Run("a server without issues.list.filters refuses before dialing", func(t *testing.T) {
proxyAddr, counter := startMaskingProxy(t, addr, withoutListFilters)
f := newHTTPFixture(t, bin, proxyAddr)
f.ids = remote.ids // same workspace behind the proxy
for _, shape := range listFilterShapes {
counter.reset()
r := f.run(nil, shape.args...)
if r.code == 0 {
t.Errorf("%s: bd %s exited 0 against a server lacking issues.list.filters: %s", shape.corpusID, strings.Join(shape.args, " "), r.stdout)
continue
}
if !strings.Contains(r.stderr+r.stdout, "issues.list.filters") {
t.Errorf("%s: the refusal does not name issues.list.filters: stdout=%s stderr=%s", shape.corpusID, r.stdout, r.stderr)
}
for _, p := range counter.snapshot() {
if p == "GET /v0/beads/issues" {
t.Errorf("%s: dialed listIssues against a server lacking issues.list.filters: %v", shape.corpusID, counter.snapshot())
break
}
}
}
})
}

View file

@ -53,15 +53,8 @@ func TestE2E_PerCommandRequestBudget(t *testing.T) {
args []string
}{
{"ready", 2, []string{"ready", "--json"}},
// The limit hides rows, and without BD_JSON_ENVELOPE nothing
// prints their count: one listing, no ready:count after it.
{"ready --limit 1", 2, []string{"ready", "--json", "--limit", "1"}},
{"list", 4, []string{"list", "--json"}},
{"show", 1, []string{"show", target, "--json"}},
// The first ready learned the server's external-dependency
// policy from the handshake; a later process reads it from the
// policy cache instead of fetching the context again.
{"ready, policy cached", 1, []string{"ready", "--json"}},
{"create", 2, []string{"create", "budget created", "-t", "task", "--json"}},
{"update --append-notes", 3, []string{"update", target, "--append-notes", "more", "--json"}},
{"update --status", 3, []string{"update", target, "--status", "in_progress", "--json"}},

View file

@ -49,24 +49,9 @@ func TestE2E_SearchOverHTTP(t *testing.T) {
t.Errorf("bd search %s did not match the issue by its id: %v", other, byID)
}
// A search filter rides listIssues behind issues.list.filters and narrows
// rather than being dropped: "pool" is in a TITLE here and in no
// description, so the answer is empty, where a dropped filter would answer
// every routed row.
r = bd("search", "routed", "--desc-contains", "pool", "--json")
if r.code != 0 {
t.Fatalf("bd search --desc-contains failed over http (exit %d): stdout=%s stderr=%s", r.code, r.stdout, r.stderr)
}
if narrowed := jsonIDSet(t, r.stdout); len(narrowed) != 0 {
t.Errorf("bd search routed --desc-contains pool = %v, want nothing: no description contains it", narrowed)
}
// And it matches: a description carrying the token answers exactly that
// row, so the empty answer above is the filter narrowing, not a filter
// that matches nothing for some other reason.
mustRun(t, bd, "update", alsoRouted, "--description", "a lantern in the description", "--json")
matched := jsonIDSet(t, mustRun(t, bd, "search", "routed", "--desc-contains", "LANTERN", "--json").stdout)
if len(matched) != 1 || !matched[alsoRouted] {
t.Errorf("bd search routed --desc-contains LANTERN = %v, want exactly %s, whose description contains it", matched, alsoRouted)
// A flag listIssues publishes nothing for refuses rather than widening the
// search.
if r := bd("search", "routed", "--desc-contains", "pool", "--json"); r.code == 0 {
t.Errorf("bd search --desc-contains succeeded over http; the wire cannot carry it, so it must refuse: %s", r.stdout)
}
}

View file

@ -118,7 +118,6 @@ const (
EventLabelAdded = types.EventLabelAdded
EventLabelRemoved = types.EventLabelRemoved
EventLeaseReclaimed = types.EventLeaseReclaimed
EventLeaseRearmed = types.EventLeaseRearmed
EventCompacted = types.EventCompacted
)

View file

@ -99,18 +99,6 @@ func configuredBackendUnavailable(backend, beadsDir string, cfg *configfile.Conf
}
}
// UnsupportedWorkspaceFormatError is returned by OpenBestAvailable,
// OpenBestAvailableWith, OpenFromConfig and OpenGated when the workspace
// declares a data model this build cannot open: a metadata.json graph_mode
// other than "dependency", such as the "link" workspaces graph-preview builds
// of bd write, or the .beads/graph-preview-format marker those builds write
// beside it (FormatMarker), whatever the metadata says. Nothing was opened,
// created or modified. Match it with errors.As to read BeadsDir, GraphMode and
// FormatMarker; the bd CLI refuses the same workspaces with exit code 16.
// Aliased here because internal/configfile is unimportable outside this
// module.
type UnsupportedWorkspaceFormatError = configfile.UnsupportedWorkspaceFormatError
// Transaction provides atomic multi-operation support within a database transaction.
// Use Storage.RunInTransaction() to obtain a Transaction instance.
type Transaction = beads.Transaction
@ -381,9 +369,6 @@ func Open(ctx context.Context, dbPath string) (Storage, error) {
// name configuration.
// beadsDir is the path to the .beads directory.
func OpenFromConfig(ctx context.Context, beadsDir string) (Storage, error) {
if err := configfile.CheckDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
return dolt.NewFromConfigWithOptions(ctx, beadsDir, &dolt.Config{CreateIfMissing: true})
}
@ -418,11 +403,6 @@ func OpenFromConfig(ctx context.Context, beadsDir string) (Storage, error) {
// operation holds one exclusively; zero means fail fast. A busy gate is
// reported as ErrGateBusy (match with errors.Is).
func OpenGated(ctx context.Context, beadsDir string, wait time.Duration) (Storage, error) {
// Before the gates: taking them creates gate files in and beside a
// workspace this build must leave untouched.
if err := configfile.CheckDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
wsGate, err := workspacegate.ForWorkspace(beadsDir)
if err != nil {
return nil, err

View file

@ -46,11 +46,6 @@ func OpenBestAvailable(ctx context.Context, beadsDir string) (Storage, error) {
// typed refusal (the matching ErrXWithoutOpenWith sentinel), never a silent
// open with the field ignored.
func OpenBestAvailableWith(ctx context.Context, beadsDir string, opts OpenOptions) (Storage, error) {
// Before Load, which can migrate a legacy config.json, and before any
// backend is chosen, as the CLI store factories do.
if err := configfile.CheckDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
cfg, err := configfile.Load(beadsDir)
if err != nil {
return nil, fmt.Errorf("loading storage metadata: %w", err)

View file

@ -32,11 +32,6 @@ func OpenBestAvailable(ctx context.Context, beadsDir string) (Storage, error) {
// rationale; behavior here is identical except that embedded Dolt is
// unavailable without CGO.
func OpenBestAvailableWith(ctx context.Context, beadsDir string, opts OpenOptions) (Storage, error) {
// Before Load, which can migrate a legacy config.json, and before any
// backend is chosen, as the CLI store factories do.
if err := configfile.CheckDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
cfg, err := configfile.Load(beadsDir)
if err != nil {
return nil, fmt.Errorf("loading storage metadata: %w", err)

View file

@ -38,10 +38,6 @@ Which tier a test belongs in, and which command runs it, is decided by
6. Regenerate the CLI reference with `scripts/generate-cli-docs.sh`;
`scripts/check-cli-docs-drift.sh` fails a PR whose command-surface change
leaves the generated docs stale.
7. Regenerate the command-surface goldens and review the testdata diff:
`BD_UPDATE_GOLDEN=1 CGO_ENABLED=1 go test -tags gms_pure_go ./cmd/bd -run '^TestCommand(Tree|Help)Golden$'`.
`TestCommandTreeGolden` fails on any added, removed or reworded command or
flag until you do.
Prefer a flag on an existing command over a new command, and route
recovery/repair operations to `bd doctor --fix`; see the CLI design principles
@ -89,9 +85,6 @@ no linter enforces it).
or serialize the call under `stdioMutex`.
- `TestCorpusGolden` (`protocol/`) — no unreviewed change to the `--json`
wire shapes.
- `TestCommandTreeGolden` and `TestCommandHelpGolden` — no unreviewed change
to the command tree (every command and flag, hidden ones included) or to
the pinned `--help` output in `testdata/command_tree/`.
Fresh-workspace command fixtures call `isolateBeadsDirForTest(t)` before
setup or dispatch and must not use `t.Parallel()`.

View file

@ -49,7 +49,6 @@ go_library(
"backup_restore.go",
"batch.go",
"batch_proxied_server.go",
"blocked_flags.go",
"bootstrap.go",
"branch.go",
"capability_registry.go",
@ -375,13 +374,9 @@ go_library(
"version.go",
"version_proxied_server.go",
"version_tracking.go",
"versioned_history.go",
"versioned_history_switch.go",
"versions.go",
"where.go",
"wisp.go",
"wisp_proxied_server.go",
"workspace_format_guard.go",
"workspace_gate.go",
"worktree.go",
"worktree_cmd.go",
@ -421,8 +416,6 @@ go_library(
"//internal/hooks",
"//internal/httpapi",
"//internal/httpclient",
"//internal/httpclient/wire",
"//internal/initprocs",
"//internal/jira",
"//internal/linear",
"//internal/lockfile",
@ -468,7 +461,6 @@ go_library(
"//internal/utils",
"//internal/validation",
"//internal/versioncheck",
"//internal/versionedhistory",
"//internal/workapi",
"//internal/workspacegate",
"//internal/worktreeremove",
@ -549,7 +541,6 @@ go_test(
"actor_test.go",
"ado_roundtrip_test.go",
"ado_test.go",
"agent_artifacts_embedded_test.go",
"agent_hook_test.go",
"assign_fence_embedded_test.go",
"assign_fence_proxied_test.go",
@ -576,7 +567,6 @@ go_test(
"batch_parity_test.go",
"batch_test.go",
"blocked_embedded_test.go",
"blocked_flags_test.go",
"blocked_proxied_integration_test.go",
"bootstrap_backend_guard_test.go",
"bootstrap_embedded_test.go",
@ -607,7 +597,6 @@ go_test(
"cobra_flag_reset_test.go",
"codex_hook_test.go",
"command_telemetry_test.go",
"command_tree_golden_test.go",
"comment_promote_embedded_test.go",
"comment_proxied_integration_test.go",
"comment_reserved_word_test.go",
@ -718,8 +707,6 @@ go_test(
"dependency_hierarchy_embedded_test.go",
"diff_embedded_test.go",
"directory_flag_test.go",
"discovery_refusal_pins_embedded_test.go",
"discovery_refusal_pins_test.go",
"doctor_backend_guard_test.go",
"doctor_check_gate_test.go",
"doctor_context_test.go",
@ -761,7 +748,6 @@ go_test(
"dolt_remote_add_test.go",
"dolt_remote_adopt_test.go",
"dolt_remote_json_test.go",
"dolt_remote_origin_guard_embedded_test.go",
"dolt_remote_origin_guard_test.go",
"dolt_remote_remove_proxied_integration_test.go",
"dolt_remote_reset_data_embedded_test.go",
@ -811,12 +797,10 @@ go_test(
"find_duplicates_test.go",
"flags_test.go",
"flatten_embedded_test.go",
"format_json_alias_embedded_test.go",
"formula_fixture_proxied_test.go",
"formula_help_test.go",
"formula_primitives_test.go",
"formula_schema_test.go",
"gate_add_waiter_contention_test.go",
"gate_check_listing_test.go",
"gate_check_proxied_integration_test.go",
"gate_discover_test.go",
@ -844,8 +828,6 @@ go_test(
"graph_apply_thread_spawner_embedded_test.go",
"graph_embedded_test.go",
"graph_export_test.go",
"graph_mode_admission_e2e_test.go",
"graph_mode_dependency_embedded_test.go",
"graph_proxied_integration_test.go",
"graph_test.go",
"graph_visual_test.go",
@ -875,7 +857,6 @@ go_test(
"identity_preview_refusal_test.go",
"if_revision_embedded_test.go",
"if_revision_gc_matcher_embedded_test.go",
"if_revision_ordinary_cas_embedded_test.go",
"if_revision_proxied_close_delete_test.go",
"if_revision_proxied_integration_test.go",
"if_revision_reassign_fence_embedded_test.go",
@ -898,13 +879,10 @@ go_test(
"info_kv_exclusion_test.go",
"info_proxied_integration_test.go",
"info_test.go",
"init_agent_test.go",
"init_cancel_e2e_test.go",
"init_commit_test.go",
"init_embedded_test.go",
"init_explicit_beads_dir_embedded_test.go",
"init_external_autostart_test.go",
"init_external_message_test.go",
"init_gateway_test.go",
"init_git_bootstrap_routing_test.go",
"init_guard_force_e2e_test.go",
@ -953,8 +931,6 @@ go_test(
"legacy_upgrade_guard_e2e_test.go",
"legacy_upgrade_guard_empty_root_test.go",
"legacy_upgrade_guard_external_server_test.go",
"legacy_upgrade_guard_init_flag_e2e_test.go",
"legacy_upgrade_guard_init_flag_test.go",
"legacy_upgrade_guard_test.go",
"legacy_upgrade_guard_witness_test.go",
"linear_roundtrip_test.go",
@ -1019,9 +995,7 @@ go_test(
"mol_bond_gwn_test.go",
"mol_bond_proxied_integration_test.go",
"mol_bond_ref_attach_test.go",
"mol_bond_routing_test.go",
"mol_bond_test.go",
"mol_bond_var_validation_test.go",
"mol_burn_proxied_integration_test.go",
"mol_current_proxied_integration_test.go",
"mol_distill_proxied_integration_test.go",
@ -1106,7 +1080,6 @@ go_test(
"ready_embedded_test.go",
"ready_explain_ids_test.go",
"ready_input_test.go",
"ready_json_no_total_test.go",
"ready_max_rows_proxied_test.go",
"ready_max_rows_test.go",
"ready_proxied_integration_test.go",
@ -1142,7 +1115,6 @@ go_test(
"restore_test.go",
"root_context_lifecycle_test.go",
"routed_local_near_miss_test.go",
"routed_mutation_test.go",
"routed_test.go",
"routing_notice_test.go",
"routing_read_remote_test.go",
@ -1169,7 +1141,6 @@ go_test(
"serve_delete_proxied_integration_test.go",
"serve_dependencies_proxied_integration_test.go",
"serve_edge_counts_proxied_integration_test.go",
"serve_graph_mode_env_test.go",
"serve_inprocess_test.go",
"serve_list_sort_proxied_integration_test.go",
"serve_proxied_integration_test.go",
@ -1265,7 +1236,6 @@ go_test(
"test_helpers_test.go",
"test_repo_beads_guard_darwin_test.go",
"test_repo_beads_guard_test.go",
"test_repo_git_guard_test.go",
"test_wait_helper_test.go",
"thread_test.go",
"tips_example_test.go",
@ -1312,14 +1282,6 @@ go_test(
"version_embedded_test.go",
"version_test.go",
"version_tracking_test.go",
"versioned_history_construction_test.go",
"versioned_history_e2e_test.go",
"versioned_history_serve_e2e_test.go",
"versioned_history_switch_scan_embedded_test.go",
"versioned_history_switch_scan_proxied_integration_test.go",
"versioned_history_switch_test.go",
"versions_switch_embedded_test.go",
"versions_test.go",
"where_cgo_test.go",
"where_embedded_test.go",
"where_test.go",
@ -1329,7 +1291,6 @@ go_test(
"wisp_gc_purge_closed_embedded_test.go",
"wisp_proxied_integration_test.go",
"wisp_test.go",
"workspace_format_guard_test.go",
"workspace_gate_test.go",
"workspace_identity_test.go",
"worktree_cmd_test.go",
@ -1350,7 +1311,6 @@ go_test(
":go_srcs",
":preflight_go_fixture",
"//:bd_test_files",
"//:go_srcs",
"//cmd/bd/doctor:go_srcs",
"//cmd/bd/doctor/fix:go_srcs",
"//internal/storage/embeddeddolt/cmd:go_srcs",
@ -1385,8 +1345,6 @@ go_test(
"//internal/httpapi",
"//internal/httpclient",
"//internal/httpclient/encode",
"//internal/httpclient/wire",
"//internal/initprocs",
"//internal/linear",
"//internal/metrics",
"//internal/migration",
@ -1418,7 +1376,6 @@ go_test(
"//internal/storage/uow",
"//internal/storage/versioncontrolops",
"//internal/telemetry",
"//internal/templates/agents",
"//internal/testutil",
"//internal/testutil/bazeltest",
"//internal/testutil/credentialcmd",
@ -1491,7 +1448,7 @@ go_test(
)
# bd_embedded_test and bd_embedded_part2_test run the TestEmbedded* functions
# of cmd/bd's _test.go files between them: the manifest's 100-shard block
# of *_embedded_test.go between them: the manifest's 100-shard block
# (duration-balanced; see scripts/ci/embedded_cmd_test_durations.json) is
# more than Bazel's 50-shard cap per rule, so bd_embedded_test runs its
# shards 1-50 and bd_embedded_part2_test its shards 51-100

View file

@ -1,310 +0,0 @@
//go:build cgo
package main
import (
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/templates/agents"
)
// TestEmbeddedInitAgentArtifactsGolden pins the Claude agent artifacts a real
// `bd init` writes — .claude/settings.json with its hook events and commands,
// CLAUDE.md and AGENTS.md with their managed sections — and what
// `bd setup claude --check`, `--remove` and a reinstall then report and leave
// behind, through the bd binary. Each scenario is a transcript golden under
// testdata/agent_artifacts/, so a change to any artifact or outcome (a new
// hook event, a changed command, new template text and its hash) shows up as
// a reviewed golden diff.
//
// A managed section is shown by its BEGIN marker line (profile and hash) and a
// pointer to the internal/templates/agents golden that pins its bytes
// (TestManagedSectionGolden), after checking the file holds exactly that
// section; one that matches no rendered variant is shown in full. The
// in-process `bd setup claude` scenarios are pinned by
// TestClaudeSetupArtifactsGolden in cmd/bd/setup.
//
// The scenarios run a direct (embedded) bd init with no Dolt remote. Not
// pinned here: a proxied-server bd init, which installs no Codex section and
// decides HasRemote from its own remote URL; a bd init with a remote, which
// renders the managed section's with-remote variant; and the Cursor files.
// AGENTS.md is shown in full apart from its managed section, so a change to
// its wrapper text or its Codex section can pass the cmd/bd/setup and
// internal/templates/agents tests and fail only here.
//
// bd runs with HOME outside the project, so an artifact written to the home
// directory instead of the project shows up under $HOME.
//
// Regenerate with
//
// BEADS_TEST_EMBEDDED_DOLT=1 BD_UPDATE_GOLDEN=1 go test -tags gms_pure_go ./cmd/bd/ -run TestEmbeddedInitAgentArtifactsGolden
func TestEmbeddedInitAgentArtifactsGolden(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
scenarios := []struct {
name string
initArgs []string
steps [][]string
}{
{
name: "init-default",
initArgs: []string{"--prefix", "aa"},
steps: [][]string{
{"setup", "claude", "--check"},
{"setup", "claude"},
{"setup", "claude", "--remove"},
{"setup", "claude", "--check"},
{"setup", "claude"},
{"setup", "claude", "--check"},
},
},
{
name: "init-agents-profile-full",
initArgs: []string{"--prefix", "ab", "--agents-profile", "full"},
steps: [][]string{
{"setup", "claude", "--check"},
},
},
}
for _, sc := range scenarios {
t.Run(sc.name, func(t *testing.T) {
t.Parallel()
// bdInit, with HOME in a directory of its own.
dir, home := t.TempDir(), t.TempDir()
initGitRepoAt(t, dir)
database, seeded := seededInitDatabase(sc.initArgs)
if seeded {
seedEmbeddedSchema(t, dir, database)
}
initArgs := append([]string{"init", "--quiet"}, sc.initArgs...)
if stdout, stderr, exitCode := runAgentArtifactCommand(t, bd, dir, home, initArgs...); exitCode != 0 {
t.Fatalf("bd %s: exit %d\nstdout:\n%s\nstderr:\n%s", strings.Join(initArgs, " "), exitCode, stdout, stderr)
}
if seeded {
requireSeededEmbeddedInit(t, filepath.Join(dir, ".beads"), database)
}
var transcript strings.Builder
fmt.Fprintf(&transcript, "# bd init agent artifact transcript: %s\n", sc.name)
fmt.Fprintf(&transcript, "# Regenerate with BEADS_TEST_EMBEDDED_DOLT=1 BD_UPDATE_GOLDEN=1 go test -tags gms_pure_go ./cmd/bd/ -run TestEmbeddedInitAgentArtifactsGolden\n")
fmt.Fprintf(&transcript, "\n=== bd %s\n", strings.Join(initArgs, " "))
previous := map[string]string{}
writeAgentArtifactChanges(t, &transcript, dir, home, previous)
for _, args := range sc.steps {
stdout, stderr, exitCode := runAgentArtifactCommand(t, bd, dir, home, args...)
fmt.Fprintf(&transcript, "\n=== bd %s\n", strings.Join(args, " "))
fmt.Fprintf(&transcript, "exit: %d\n", exitCode)
writeAgentArtifactBlock(&transcript, "stdout", normalizeAgentArtifactOutput(stdout, dir, home))
writeAgentArtifactBlock(&transcript, "stderr", normalizeAgentArtifactOutput(stderr, dir, home))
writeAgentArtifactChanges(t, &transcript, dir, home, previous)
}
assertAgentArtifactGolden(t, filepath.Join("testdata", "agent_artifacts", sc.name+".golden"), transcript.String())
})
}
}
// agentArtifactPaths are the Claude agent artifacts bd init and bd setup
// claude write in a project ($PROJECT), and those in the home directory
// ($HOME): the $HOME/.claude/ files a global install writes, and the
// $HOME/CLAUDE.md an older --global run from $HOME wrote.
var agentArtifactPaths = []string{
"$PROJECT/.claude/settings.json",
"$PROJECT/.claude/settings.local.json",
"$PROJECT/AGENTS.md",
"$PROJECT/CLAUDE.md",
"$HOME/.claude/settings.json",
"$HOME/.claude/CLAUDE.md",
"$HOME/CLAUDE.md",
}
// agentArtifactManagedSections maps each managed section bd renders to the
// internal/templates/agents golden file that pins its bytes.
var agentArtifactManagedSections = []struct {
golden string
profile agents.Profile
opts agents.RenderOpts
}{
{golden: "managed-section-minimal.md", profile: agents.ProfileMinimal, opts: agents.RenderOpts{HasRemote: true}},
{golden: "managed-section-minimal-no-remote.md", profile: agents.ProfileMinimal, opts: agents.RenderOpts{}},
{golden: "managed-section-minimal-user.md", profile: agents.ProfileMinimal, opts: agents.UserLevelRenderOpts()},
{golden: "managed-section-full.md", profile: agents.ProfileFull, opts: agents.RenderOpts{HasRemote: true}},
{golden: "managed-section-full-no-remote.md", profile: agents.ProfileFull, opts: agents.RenderOpts{}},
{golden: "managed-section-full-user.md", profile: agents.ProfileFull, opts: agents.UserLevelRenderOpts()},
}
// elideAgentArtifactManagedSection replaces the body of a managed section
// that is byte-identical to a rendered variant with a pointer to that
// variant's golden, keeping the BEGIN marker line (profile and hash) and the
// END marker.
func elideAgentArtifactManagedSection(content string) string {
const endMarker = "<!-- END BEADS INTEGRATION -->\n"
begin := strings.Index(content, "<!-- BEGIN BEADS INTEGRATION")
if begin < 0 {
return content
}
rel := strings.Index(content[begin:], endMarker)
if rel < 0 {
return content
}
end := begin + rel + len(endMarker)
section := content[begin:end]
for _, v := range agentArtifactManagedSections {
if section == agents.RenderSectionWithOpts(v.profile, v.opts) {
marker, _, _ := strings.Cut(section, "\n")
return content[:begin] + marker + "\n[managed section body: byte-identical to internal/templates/agents/testdata/" + v.golden + "]\n" + endMarker + content[end:]
}
}
return content
}
// runAgentArtifactCommand runs bd in dir with HOME at home and returns its
// stdout, stderr and exit code.
func runAgentArtifactCommand(t *testing.T, bd, dir, home string, args ...string) (stdout, stderr string, exitCode int) {
t.Helper()
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = agentArtifactEnv(dir, home)
outBuf, errBuf, err := runCommandBuffers(t, cmd)
if err != nil {
var exitErr *exec.ExitError
if !errors.As(err, &exitErr) {
t.Fatalf("bd %s: %v", strings.Join(args, " "), err)
}
exitCode = exitErr.ExitCode()
}
return outBuf.String(), errBuf.String(), exitCode
}
// agentArtifactEnv is bdEnv(dir) with HOME at home and without the caller's
// BD_OTEL_* and OTEL_* variables: bd warns on stderr about a legacy BD_OTEL_*
// one whether or not telemetry is on, and the transcript pins stderr byte for
// byte. (clearTelemetryEnv cannot be used: it calls t.Setenv, and these tests
// run in parallel.)
func agentArtifactEnv(dir, home string) []string {
var env []string
for _, e := range bdEnv(dir) {
if strings.HasPrefix(e, "BD_OTEL_") || strings.HasPrefix(e, "OTEL_") || strings.HasPrefix(e, "HOME=") {
continue
}
env = append(env, e)
}
return append(env, "HOME="+home)
}
// writeAgentArtifactChanges appends every artifact created, modified or
// deleted since previous (which it then updates), with its contents.
func writeAgentArtifactChanges(t *testing.T, b *strings.Builder, dir, home string, previous map[string]string) {
t.Helper()
roots := strings.NewReplacer("$PROJECT", dir, "$HOME", home)
changed := false
for _, path := range agentArtifactPaths {
data, err := os.ReadFile(filepath.FromSlash(roots.Replace(path)))
before, existed := previous[path]
switch {
case os.IsNotExist(err):
if existed {
fmt.Fprintf(b, "--- files: deleted %s\n", path)
delete(previous, path)
changed = true
}
case err != nil:
t.Fatalf("read %s: %v", path, err)
case !existed || before != string(data):
verb := "created"
if existed {
verb = "modified"
}
shown := string(data)
if strings.HasSuffix(path, ".md") {
shown = elideAgentArtifactManagedSection(shown)
}
writeAgentArtifactBlock(b, fmt.Sprintf("files: %s %s", verb, path), shown)
previous[path] = string(data)
changed = true
}
}
if !changed {
b.WriteString("--- files: unchanged\n")
}
}
// writeAgentArtifactBlock appends a titled block, marking empty content and a
// missing trailing newline so neither is lost in the golden.
func writeAgentArtifactBlock(b *strings.Builder, title, content string) {
fmt.Fprintf(b, "--- %s\n", title)
switch {
case content == "":
b.WriteString("(empty)\n")
case !strings.HasSuffix(content, "\n"):
b.WriteString(content)
b.WriteString("\n(no newline at end of file)\n")
default:
b.WriteString(content)
}
}
// normalizeAgentArtifactOutput replaces the project and home directories (as
// given and with symlinks resolved, since bd reports the paths it sees) with
// $PROJECT and $HOME and uses forward slashes, so the transcript is the same
// on every host.
func normalizeAgentArtifactOutput(s, dir, home string) string {
for _, root := range []struct{ path, label string }{{dir, "$PROJECT"}, {home, "$HOME"}} {
if resolved, err := filepath.EvalSymlinks(root.path); err == nil && resolved != root.path {
s = strings.ReplaceAll(s, resolved, root.label)
}
s = strings.ReplaceAll(s, root.path, root.label)
}
if filepath.Separator != '/' {
s = strings.ReplaceAll(s, string(filepath.Separator), "/")
}
return s
}
// assertAgentArtifactGolden compares got with the golden file at path, or
// rewrites the file when BD_UPDATE_GOLDEN=1.
func assertAgentArtifactGolden(t *testing.T, path, got string) {
t.Helper()
if os.Getenv("BD_UPDATE_GOLDEN") == "1" {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatalf("mkdir %s: %v", filepath.Dir(path), err)
}
if err := os.WriteFile(path, []byte(got), 0o644); err != nil {
t.Fatalf("write golden %s: %v", path, err)
}
t.Logf("updated golden %s", path)
return
}
want, err := os.ReadFile(path)
if err != nil {
t.Fatalf("read golden %s (regenerate with BD_UPDATE_GOLDEN=1): %v", path, err)
}
if got == string(want) {
return
}
wantLines, gotLines := strings.Split(string(want), "\n"), strings.Split(got, "\n")
line := func(lines []string, i int) string {
if i >= len(lines) {
return "(end of output)"
}
return fmt.Sprintf("%q", lines[i])
}
i := 0
for i < len(wantLines) && i < len(gotLines) && wantLines[i] == gotLines[i] {
i++
}
t.Errorf("bd init agent artifacts drifted from %s (regenerate with BD_UPDATE_GOLDEN=1 if intended)\nfirst difference at line %d:\n want: %s\n got: %s\n--- got ---\n%s", path, i+1, line(wantLines, i), line(gotLines, i), got)
}

View file

@ -43,7 +43,7 @@ func bdRunOK(t *testing.T, bd, dir string, args ...string) string {
return string(out)
}
// TestEmbeddedReassignFenceCLI drives the bd-98s5c live-claim reassign fence
// TestReassignFenceCLI drives the bd-98s5c live-claim reassign fence
// end-to-end: plain `bd update -a` and `bd assign` were the last unfenced
// cross-actor takeover path (--claim, unclaim, and close all refuse without
// --force). The fence must refuse ONLY the silent steamroll — a different
@ -51,7 +51,7 @@ func bdRunOK(t *testing.T, bd, dir string, args ...string) string {
// leave routine dispatch untouched: open-bead reassigns, self-edits,
// idempotent re-asserts, pool-alias takes, and holder-aware --if-assignee
// transfers all proceed without --force.
func TestEmbeddedReassignFenceCLI(t *testing.T) {
func TestReassignFenceCLI(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -12,23 +12,10 @@ import (
// the rejection inspects it (read-only) so a workspace that already holds a Dolt
// database is told to fix the stale "backend" value rather than to export and
// reinitialize. Pass "" only where there is genuinely no workspace directory.
//
// It also refuses metadata that declares a workspace format this build cannot
// open (checkWorkspaceFormat). Command admission refuses those first, and the
// store factories check before their migrating configfile.Load
// (checkDiscoveredWorkspaceFormat), so here it backs up any other caller that
// validates metadata it loaded itself. It returns early for a nil cfg, so that
// backstop covers the graph format marker only when metadata was loaded; a
// caller that may have none must check beadsDir with
// checkDiscoveredWorkspaceFormat or command admission first, as every caller
// does today.
func validateConfiguredBackend(cfg *configfile.Config, beadsDir string) error {
if cfg == nil {
return nil
}
if err := checkWorkspaceFormat(cfg, beadsDir); err != nil {
return err
}
if backends.Registered(cfg.Backend) {
return nil
}
@ -93,16 +80,14 @@ func openStoreError(backendName string, err error) error {
return fmt.Errorf("failed to open database: %w", err)
}
// backendNameForErrorFraming best-effort reads metadata.json to learn which
// backendNameForErrorFraming best-effort loads metadata.json to learn which
// backend a failed open was for, so a caller that does not already have cfg
// in scope (for example direct mode's single-shot store-open) can still give
// openStoreError the name it needs. A failure to even read the config
// degrades to "" — openStoreError's default, Dolt-shaped framing — rather
// than compounding one error with another. It reads with LoadForDiscovery:
// the open it frames may have just refused the workspace, and
// configfile.Load would migrate a legacy config.json into metadata.json.
// than compounding one error with another.
func backendNameForErrorFraming(beadsDir string) string {
cfg, err := configfile.LoadForDiscovery(beadsDir)
cfg, err := configfile.Load(beadsDir)
if err != nil || cfg == nil {
return ""
}
@ -110,12 +95,6 @@ func backendNameForErrorFraming(beadsDir string) string {
}
func loadDoltBackendConfig(beadsDir string) (*configfile.Config, error) {
// Refuse a workspace format this build cannot open before configfile.Load,
// which would otherwise migrate a legacy config.json into metadata.json
// before requireDoltBackend's own format check could refuse it.
if err := checkDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
cfg, err := configfile.Load(beadsDir)
if err != nil {
return nil, fmt.Errorf("loading config: %w", err)

View file

@ -53,8 +53,6 @@ After adding, run 'bd backup sync' to push your data.`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
CheckReadonly("backup init")
evt := metrics.NewCommandEvent("backup-init")
defer func() {
if c := metrics.Global(); c != nil {
@ -136,8 +134,6 @@ Run 'bd backup init <path>' first to configure a destination.`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
CheckReadonly("backup sync")
evt := metrics.NewCommandEvent("backup-sync")
defer func() {
if c := metrics.Global(); c != nil {
@ -443,8 +439,6 @@ backup configuration. The backup data at the destination is not deleted.`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
CheckReadonly("backup remove")
evt := metrics.NewCommandEvent("backup-remove")
defer func() {
if c := metrics.Global(); c != nil {

View file

@ -217,78 +217,3 @@ func TestEmbeddedBackupConcurrent(t *testing.T) {
t.Error("backup destination should exist after concurrent syncs")
}
}
// TestEmbeddedBackupRestoreStrictReadonly pins the refusal of a strict
// --readonly restore. A restore replaces the store, so CheckReadonly must stop
// it with the standard message before the command takes the exclusive workspace
// gate. Embedded mode used to be stopped only by the storage layer
// ("embeddeddolt: store is read-only"), after the gate had already left its
// holder files in the workspace. The control proves the fixture really does
// restore when --readonly is not asked for, so "the store is unchanged" below
// cannot be vacuous.
func TestEmbeddedBackupRestoreStrictReadonly(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt backup tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
// newWorkspace returns a workspace whose live store holds one issue its
// backup does not (three against two), so a restore that really ran shows up
// as a changed issue count. Each case gets its own: a restore that runs
// replaces the store and would hide a leak from the next.
newWorkspace := func(t *testing.T, prefix string) (dir, backupDir string) {
t.Helper()
dir, _, _ = bdInit(t, bd, "--prefix", prefix)
bdCreateSilent(t, bd, dir, "issue in the backup A")
bdCreateSilent(t, bd, dir, "issue in the backup B")
backupDir = filepath.Join(t.TempDir(), "dolt-backup")
if err := os.MkdirAll(backupDir, 0o750); err != nil {
t.Fatal(err)
}
bdBackup(t, bd, dir, "init", "file://"+backupDir)
bdBackup(t, bd, dir, "sync")
bdCreateSilent(t, bd, dir, "issue created after the backup")
return dir, backupDir
}
t.Run("control_restore_without_readonly", func(t *testing.T) {
dir, backupDir := newWorkspace(t, "rrctl")
stdout, stderr, code := runBDMigrationFreeze(t, bd, dir, "backup", "restore", "--force", backupDir)
if code != 0 {
t.Fatalf("restore without --readonly exited %d\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
if !strings.Contains(stdout, "Restore complete") {
t.Errorf("stdout is missing %q:\n%s", "Restore complete", stdout)
}
if got := len(bdListJSON(t, bd, dir)); got != 2 {
t.Errorf("issue count after a real restore = %d, want 2: the backup holds two issues and the live store held three", got)
}
})
for _, tc := range []struct {
name string
prefix string
flags []string
}{
{"readonly", "rrro", []string{"--readonly"}},
{"readonly_sandbox", "rrrosb", []string{"--readonly", "--sandbox"}},
} {
t.Run(tc.name, func(t *testing.T) {
dir, backupDir := newWorkspace(t, tc.prefix)
before := snapshotWorkspace(t, dir)
args := append(append([]string{}, tc.flags...), "backup", "restore", "--force", backupDir)
stdout, stderr, code := runBDMigrationFreeze(t, bd, dir, args...)
assertStrictReadonlyRestoreRefused(t, stdout, stderr, code)
assertWorkspaceUnchanged(t, dir, before)
if got := len(bdListJSON(t, bd, dir)); got != 3 {
t.Errorf("issue count after the refused restore = %d, want 3: the restore replaced the store", got)
}
})
}
}

View file

@ -34,8 +34,6 @@ To initialize and restore in one step, use: bd init && bd backup restore`,
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
CheckReadonly("backup restore")
evt := metrics.NewCommandEvent("backup-restore")
defer func() {
if c := metrics.Global(); c != nil {

View file

@ -4,22 +4,14 @@ package main
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"slices"
"sort"
"strings"
"testing"
"time"
"github.com/steveyegge/beads/internal/beads"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/git"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/testutil"
"github.com/steveyegge/beads/internal/types"
)
func TestBackupRestoreMissingDir(t *testing.T) {
@ -92,257 +84,3 @@ func TestSyncProjectIDFromDB_NoWorkspaceUsesActiveWorkspaceError(t *testing.T) {
t.Fatalf("syncProjectIDFromDB should not create local .beads, stat err = %v", statErr)
}
}
// strictReadonlyRestoreRefusal is the line CheckReadonly prints when a write
// command is run under strict --readonly.
const strictReadonlyRestoreRefusal = "Error: operation 'backup restore' is not allowed in read-only mode\n"
// assertStrictReadonlyRestoreRefused checks one refused `bd --readonly backup
// restore` run: the standard CheckReadonly refusal (text and exit code), nothing
// on stdout, and none of the storage-layer message that embedded mode gives when
// the command gets past CheckReadonly and opens the store.
func assertStrictReadonlyRestoreRefused(t *testing.T, stdout, stderr string, code int) {
t.Helper()
if code != 1 {
t.Errorf("exit code = %d, want 1\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
if !strings.Contains(stderr, strictReadonlyRestoreRefusal) {
t.Errorf("stderr is missing the standard refusal %q:\n%s", strictReadonlyRestoreRefusal, stderr)
}
if strings.Contains(stderr, "embeddeddolt: store is read-only") {
t.Errorf("stderr carries the storage-layer refusal, so the command opened the store before being refused:\n%s", stderr)
}
if strings.TrimSpace(stdout) != "" {
t.Errorf("stdout should be empty when the restore is refused, got:\n%s", stdout)
}
}
// workspaceSnapshot is what a refused command must leave alone: the entries of
// the project directory (the workspace gate file and its holder sidecar sit
// beside .beads, not in it) and everything below .beads, content included.
type workspaceSnapshot struct {
projectEntries []string
beads readonlyTreeSnapshot
}
func snapshotWorkspace(t *testing.T, dir string) workspaceSnapshot {
t.Helper()
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatal(err)
}
names := make([]string, 0, len(entries))
for _, e := range entries {
names = append(names, e.Name())
}
return workspaceSnapshot{
projectEntries: names,
beads: snapshotReadonlyTree(t, filepath.Join(dir, ".beads")),
}
}
// assertWorkspaceUnchanged fails, naming each path, when the workspace under dir
// no longer matches a snapshot taken before a refused command.
func assertWorkspaceUnchanged(t *testing.T, dir string, before workspaceSnapshot) {
t.Helper()
after := snapshotWorkspace(t, dir)
var diffs []string
for _, name := range before.projectEntries {
if !slices.Contains(after.projectEntries, name) {
diffs = append(diffs, "removed: "+name)
}
}
for _, name := range after.projectEntries {
if !slices.Contains(before.projectEntries, name) {
diffs = append(diffs, "created: "+name)
}
}
for path, want := range before.beads.Entries {
switch got, ok := after.beads.Entries[path]; {
case !ok:
diffs = append(diffs, "removed: .beads/"+path)
case got != want:
diffs = append(diffs, "changed: .beads/"+path)
}
}
for path := range after.beads.Entries {
if _, ok := before.beads.Entries[path]; !ok {
diffs = append(diffs, "created: .beads/"+path)
}
}
if len(diffs) == 0 {
return
}
sort.Strings(diffs)
const show = 20
if len(diffs) > show {
diffs = append(diffs[:show], fmt.Sprintf("... and %d more", len(diffs)-show))
}
t.Errorf("the refused restore changed the workspace:\n%s", strings.Join(diffs, "\n"))
}
// TestBackupRestoreStrictReadonlyServerMode is the server-mode counterpart of
// TestEmbeddedBackupRestoreStrictReadonly. Server mode is where the missing
// refusal mattered: no storage layer stops a server connection, so a
// `bd --readonly backup restore --force` ran to the end and replaced the store.
// It drives the built bd as a subprocess because CheckReadonly exits the
// process. Both the fixture's backup and the restore run inside the Dolt
// server, against the same path on the server's own filesystem, so a local
// and a containerized test server both serve.
func TestBackupRestoreStrictReadonlyServerMode(t *testing.T) {
if testDoltServerPort == 0 {
t.Skip("Dolt test server not available")
}
if testutil.DoltContainerCrashed() {
t.Skipf("Dolt test server crashed: %v", testutil.DoltContainerCrashError())
}
bd := buildBDForInitTests(t)
// newWorkspace builds a server-mode workspace on the test server whose live
// store holds one issue its backup does not (three against two), so a restore
// that really ran shows up as a changed issue count. Each case gets its own: a
// restore that runs replaces the store and would hide a leak from the next.
newWorkspace := func(t *testing.T) (dir string, env []string, backupDir string) {
t.Helper()
dir = t.TempDir()
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0o700); err != nil {
t.Fatal(err)
}
database := uniqueTestDBName(t)
if err := (&configfile.Config{
Backend: configfile.BackendDolt,
DoltMode: configfile.DoltModeServer,
DoltServerHost: "127.0.0.1",
DoltServerPort: testDoltServerPort,
DoltDatabase: database,
}).Save(beadsDir); err != nil {
t.Fatalf("save workspace metadata: %v", err)
}
ctx := context.Background()
seedStore, err := dolt.New(ctx, &dolt.Config{
Path: filepath.Join(beadsDir, "dolt"),
BeadsDir: beadsDir,
ServerHost: "127.0.0.1",
ServerPort: testDoltServerPort,
Database: database,
CreateIfMissing: true,
})
if err != nil {
t.Fatalf("create the server-mode database: %v", err)
}
t.Cleanup(func() { dropTestDatabase(database, testDoltServerPort) })
defer func() { _ = seedStore.Close() }()
if err := seedStore.SetConfig(ctx, "issue_prefix", "rr"); err != nil {
t.Fatalf("set issue_prefix: %v", err)
}
seed := func(id, title string) {
t.Helper()
now := time.Now()
issue := &types.Issue{
ID: id,
Title: title,
Status: types.StatusOpen,
Priority: 2,
IssueType: types.TypeTask,
CreatedAt: now,
UpdatedAt: now,
}
if err := seedStore.CreateIssue(ctx, issue, "test-user"); err != nil {
t.Fatalf("create issue %s: %v", id, err)
}
}
commit := func(message string) {
t.Helper()
if err := seedStore.Commit(ctx, message); err != nil && !strings.Contains(err.Error(), "nothing to commit") {
t.Fatalf("commit %q: %v", message, err)
}
}
seed("rr-1", "issue in the backup A")
seed("rr-2", "issue in the backup B")
commit("issues the backup holds")
backupDir = filepath.Join(t.TempDir(), "dolt-backup")
if err := os.MkdirAll(backupDir, 0o750); err != nil {
t.Fatal(err)
}
if err := seedStore.BackupDatabase(ctx, backupDir); err != nil {
t.Fatalf("back up the database (the Dolt server must be able to write %s): %v", backupDir, err)
}
seed("rr-3", "issue created after the backup")
commit("issue the backup lacks")
env = []string{
"BEADS_TEST_MODE=1",
// The subprocess connects to a testdb_* database on the test server;
// this is the opt-in the test-database firewall asks for.
"BEADS_TEST_SERVER=1",
"BEADS_DIR=" + beadsDir,
"XDG_CONFIG_HOME=" + t.TempDir(),
// Keep the subprocess's circuit-breaker state in the suite's own
// directory rather than the host's temp dir.
"BEADS_TEST_CIRCUIT_DIR=" + os.Getenv("BEADS_TEST_CIRCUIT_DIR"),
}
return dir, env, backupDir
}
issueCount := func(t *testing.T, dir string, env []string) int {
t.Helper()
stdout, stderr, code := runBDMigrationFreezeWithEnv(t, bd, dir, env, "list", "--json")
if code != 0 {
t.Fatalf("bd list --json exited %d\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
start := strings.Index(stdout, "[")
if start < 0 {
t.Fatalf("no JSON array in bd list --json output:\n%s", stdout)
}
var issues []json.RawMessage
if err := json.Unmarshal([]byte(stdout[start:]), &issues); err != nil {
t.Fatalf("parse bd list --json output: %v\n%s", err, stdout)
}
return len(issues)
}
// The control proves the fixture really does restore when --readonly is not
// asked for, so "the store is unchanged" below cannot be vacuous.
t.Run("control_restore_without_readonly", func(t *testing.T) {
dir, env, backupDir := newWorkspace(t)
stdout, stderr, code := runBDMigrationFreezeWithEnv(t, bd, dir, env, "backup", "restore", "--force", backupDir)
if code != 0 {
t.Fatalf("restore without --readonly exited %d\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
if !strings.Contains(stdout, "Restore complete") {
t.Errorf("stdout is missing %q:\n%s", "Restore complete", stdout)
}
if got := issueCount(t, dir, env); got != 2 {
t.Errorf("issue count after a real restore = %d, want 2: the backup holds two issues and the live store held three", got)
}
})
for _, tc := range []struct {
name string
flags []string
}{
{"readonly", []string{"--readonly"}},
{"readonly_sandbox", []string{"--readonly", "--sandbox"}},
} {
t.Run(tc.name, func(t *testing.T) {
dir, env, backupDir := newWorkspace(t)
before := snapshotWorkspace(t, dir)
args := append(append([]string{}, tc.flags...), "backup", "restore", "--force", backupDir)
stdout, stderr, code := runBDMigrationFreezeWithEnv(t, bd, dir, env, args...)
assertStrictReadonlyRestoreRefused(t, stdout, stderr, code)
assertWorkspaceUnchanged(t, dir, before)
if got := issueCount(t, dir, env); got != 3 {
t.Errorf("issue count after the refused restore = %d, want 3: the restore replaced the store", got)
}
})
}
}

View file

@ -234,7 +234,7 @@ func TestEmbeddedBlockedLabelFilters(t *testing.T) {
}
})
// the blocked role normalizes, as every sibling label filter does.
// blockedFilterFromFlags normalizes, as every sibling label filter does.
// Without it an untrimmed value returns nothing and is indistinguishable
// from "nothing blocked carries that label".
t.Run("leading_space_is_trimmed_like_every_other_label_filter", func(t *testing.T) {

View file

@ -1,167 +0,0 @@
package main
import (
"bufio"
"context"
"fmt"
"io"
"strings"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/storage/uow"
"github.com/steveyegge/beads/issueops"
)
// blockedFlagRow is one line of `bd blocked --flags --json`: an id the caller
// named and the blocked flag bd holds for it.
type blockedFlagRow struct {
ID string `json:"id"`
IsBlocked bool `json:"is_blocked"`
}
// blockedFlagFilterFlags are the listing's filters, which --flags does not
// take: it answers about the ids it is handed, not about a set it derives.
var blockedFlagFilterFlags = []string{"parent", "label", "label-any", "exclude-label"}
// runBlockedFlags is `bd blocked --flags`: the blocked flag for each id read
// from stdin (one per line; blank lines and repeats ignored), through the
// issueops.BlockedFlags library entry over the route's BlockingAnnotator.
//
// IT IS THE FLAG, NOT THE LISTING. The listing narrows the stored flag to
// rows bd can name a blocker for; this answers the flag itself, the column
// `bd ready` filters on, so a row whose flag is set with no nameable blocker
// reads true here and is absent from the listing. Where the
// external-dependency policy applies, an unsatisfied external: blocker sets
// the flag as it keeps the row out of `bd ready`.
//
// Every id that names a row on either plane is answered, in the order the ids
// were first given, a closed row included (its flag is whatever is stored);
// an id naming no row is omitted. Over HTTP the read is
// listBlockingAnnotations with is_blocked, behind
// dependencies.blocking.isBlocked; a server without that token is refused
// before the dial, naming it.
//
// --raw answers the stored column itself, without the external-dependency
// decoration (blockedFlagsAnnotator): exactly what reading is_blocked from
// the issues and wisps tables returns.
func runBlockedFlags(cmd *cobra.Command, ctx context.Context, in io.Reader) error {
for _, name := range blockedFlagFilterFlags {
if cmd.Flags().Changed(name) {
return HandleErrorRespectJSON("--flags answers the ids read from stdin and takes no --%s", name)
}
}
ids, err := readBlockedFlagIDs(in)
if err != nil {
return HandleErrorRespectJSON("reading ids from stdin: %v", err)
}
raw, _ := cmd.Flags().GetBool("raw")
annotator, err := blockedFlagsAnnotator(ctx, raw)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
flags, err := issueops.BlockedFlags(ctx, annotator, ids)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
rows := make([]blockedFlagRow, 0, len(flags))
seen := make(map[string]bool, len(ids))
for _, id := range ids {
blocked, ok := flags[id]
if !ok || seen[id] {
continue
}
seen[id] = true
rows = append(rows, blockedFlagRow{ID: id, IsBlocked: blocked})
}
if jsonOutput {
return outputJSON(rows)
}
for _, row := range rows {
state := "not blocked"
if row.IsBlocked {
state = "blocked"
}
fmt.Printf("%s\t%s\n", row.ID, state)
}
return nil
}
// readBlockedFlagIDs reads one id per line, trimmed, skipping blank lines.
func readBlockedFlagIDs(in io.Reader) ([]string, error) {
var ids []string
scanner := bufio.NewScanner(in)
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
for scanner.Scan() {
if id := strings.TrimSpace(scanner.Text()); id != "" {
ids = append(ids, id)
}
}
return ids, scanner.Err()
}
// blockedFlagsAnnotator is the BlockingAnnotator for the route this
// invocation runs: the store's own accessor on the direct routes (dolt,
// embedded dolt, HTTP), and the proxied-server provider's on the proxied one.
// Both carry the external-dependency decoration the rest of bd reads through.
//
// With raw it is the same role taken from BENEATH every decorator (the
// innermost store, the innermost provider), so the answer is the stored
// is_blocked column and nothing else: an unsatisfied external: blocker does
// not set it, because the column has never known about other projects.
func blockedFlagsAnnotator(ctx context.Context, raw bool) (issueops.BlockingAnnotator, error) {
if !raw {
if usesProxiedServer() {
return proxiedBlockingAnnotator()
}
if store == nil {
return nil, fmt.Errorf("no storage available")
}
return store.BlockingAnnotator()
}
if usesProxiedServer() {
if uowProvider == nil {
return nil, fmt.Errorf("proxied-server UOW provider not initialized")
}
src, ok := uow.UnwrapProvider(uowProvider).(uow.BlockingAnnotatorSource)
if !ok {
return nil, fmt.Errorf("proxied-server provider %T does not offer the blocking-decoration surface", uowProvider)
}
return src.BlockingAnnotator()
}
if store == nil {
return nil, fmt.Errorf("no storage available")
}
base := storage.UnwrapStore(store)
if err := refuseRawFlagsFromAPolicyServer(ctx, base); err != nil {
return nil, err
}
return base.BlockingAnnotator()
}
// refuseRawFlagsFromAPolicyServer refuses --raw against a served workspace
// whose server applies the external-dependency policy itself
// (policy.external_dependencies). That server's blocking annotation already
// sets the flag for an unsatisfied external: blocker, the v0 wire has no
// member that asks it for the bare column, and the decorated flag cannot be
// turned back into the column on this side (a row that is externally blocked
// may or may not also carry the stored flag). Answering anyway would be the
// decorated flag spelled as the raw one. Against a server that does not apply
// the policy, its annotation IS the column, and --raw is served.
func refuseRawFlagsFromAPolicyServer(ctx context.Context, base storage.DoltStorage) error {
prober, ok := base.(storage.ExternalDependencyPolicyProber)
if !ok {
return nil
}
enforced, err := prober.ServerEnforcesExternalDependencyPolicy(ctx)
if err != nil {
return err
}
if enforced {
return fmt.Errorf("bd blocked --flags --raw is not served by this workspace's server: it applies the " +
"external-dependency policy (policy.external_dependencies) to the blocked flag it answers, and the v0 " +
"wire cannot ask it for the stored column; use bd blocked --flags (the policy-aware flag)")
}
return nil
}

View file

@ -1,57 +0,0 @@
package main
import (
"slices"
"testing"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)
// TestBlockedFlagsRefusesEveryListingFilter pins blockedFlagFilterFlags to the
// flags blockedCmd registers. --flags answers the ids read from stdin, so a
// listing filter it does not refuse is silently ignored: a filter added to
// blockedCmd but not to the refusal list would answer every id while the
// caller believes the answer was narrowed. The reverse direction catches an
// entry naming no registered flag, which Changed never reports as set.
//
// It walks Flags() and PersistentFlags() with VisitAll, not LocalFlags(),
// which would merge the root's persistent flags into blockedCmd for the rest
// of the process (see TestNoSubcommandShadowsRootJSONFlag). A root flag that
// an earlier in-process run already merged in is skipped by identity, and
// cobra's own --help by its annotation.
func TestBlockedFlagsRefusesEveryListingFilter(t *testing.T) {
// The flags --flags itself reads: the mode switch and its qualifier.
modeFlags := []string{"flags", "raw"}
var registered []string
visit := func(f *pflag.Flag) {
if f == rootCmd.PersistentFlags().Lookup(f.Name) || len(f.Annotations[cobra.FlagSetByCobraAnnotation]) > 0 {
return
}
if !slices.Contains(registered, f.Name) {
registered = append(registered, f.Name)
}
}
blockedCmd.PersistentFlags().VisitAll(visit)
blockedCmd.Flags().VisitAll(visit)
for _, name := range modeFlags {
if !slices.Contains(registered, name) {
t.Errorf("blockedCmd registers no --%s; this test's mode flags are stale", name)
}
}
for _, name := range registered {
if !slices.Contains(modeFlags, name) && !slices.Contains(blockedFlagFilterFlags, name) {
t.Errorf("--%s is registered on blockedCmd but --flags does not refuse it: add it to blockedFlagFilterFlags, or to this test's mode flags if --flags reads it", name)
}
}
for _, name := range blockedFlagFilterFlags {
if slices.Contains(modeFlags, name) {
t.Errorf("blockedFlagFilterFlags refuses --%s, which --flags itself reads", name)
}
if !slices.Contains(registered, name) {
t.Errorf("blockedFlagFilterFlags names --%s, which blockedCmd does not register", name)
}
}
}

View file

@ -5,8 +5,6 @@ package main
import (
"bytes"
"encoding/json"
"os/exec"
"slices"
"strings"
"testing"
@ -83,68 +81,6 @@ func TestProxiedServerBlocked(t *testing.T) {
}
})
t.Run("flags_reads_ids_from_stdin", func(t *testing.T) {
t.Parallel()
p := newSharedProxiedProject(t, bd, "bkf")
blocker := bdProxiedCreate(t, bd, p.dir, "Flag blocker")
dependent := bdProxiedCreate(t, bd, p.dir, "Flag dependent", "--deps", "depends-on:"+blocker.ID)
cmd := exec.Command(bd, "blocked", "--flags", "--json")
cmd.Dir = p.dir
cmd.Env = bdProxiedEnv(p.dir)
cmd.Stdin = strings.NewReader(dependent.ID + "\n" + blocker.ID + "\nbk-no-such-row\n")
var stdout, stderr bytes.Buffer
cmd.Stdout, cmd.Stderr = &stdout, &stderr
if err := cmd.Run(); err != nil {
t.Fatalf("bd blocked --flags --json: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
var rows []struct {
ID string `json:"id"`
IsBlocked bool `json:"is_blocked"`
}
if err := json.Unmarshal(bytes.TrimSpace(stdout.Bytes()), &rows); err != nil {
t.Fatalf("parse: %v\n%s", err, stdout.String())
}
if len(rows) != 2 || rows[0].ID != dependent.ID || !rows[0].IsBlocked || rows[1].ID != blocker.ID || rows[1].IsBlocked {
t.Errorf("rows = %+v, want [{%s true} {%s false}] (unknown id omitted)", rows, dependent.ID, blocker.ID)
}
})
t.Run("flags_raw_is_the_stored_column", func(t *testing.T) {
t.Parallel()
p := newSharedProxiedProject(t, bd, "bkr")
ext := bdProxiedCreate(t, bd, p.dir, "Externally blocked only")
if _, stderr, err := bdProxiedRunBuffers(t, bd, p.dir, "dep", "add", ext.ID, "external:otherproj:cap"); err != nil {
t.Fatalf("dep add external: %v\n%s", err, stderr)
}
flag := func(args ...string) bool {
t.Helper()
cmd := exec.Command(bd, append([]string{"blocked", "--flags", "--json"}, args...)...)
cmd.Dir = p.dir
cmd.Env = bdProxiedEnv(p.dir)
cmd.Stdin = strings.NewReader(ext.ID + "\n")
var stdout, stderr bytes.Buffer
cmd.Stdout, cmd.Stderr = &stdout, &stderr
if err := cmd.Run(); err != nil {
t.Fatalf("bd blocked --flags %v: %v\n%s\n%s", args, err, stdout.String(), stderr.String())
}
var rows []struct {
ID string `json:"id"`
IsBlocked bool `json:"is_blocked"`
}
if err := json.Unmarshal(bytes.TrimSpace(stdout.Bytes()), &rows); err != nil || len(rows) != 1 {
t.Fatalf("parse %v: %v\n%s", args, err, stdout.String())
}
return rows[0].IsBlocked
}
if !flag() {
t.Errorf("--flags for an externally blocked row = false, want true (the policy flag)")
}
if flag("--raw") {
t.Errorf("--flags --raw for an externally blocked row = true, want false (the stored column)")
}
})
t.Run("empty_case", func(t *testing.T) {
t.Parallel()
p := newSharedProxiedProject(t, bd, "bk2")
@ -189,42 +125,4 @@ func TestProxiedServerBlocked(t *testing.T) {
t.Errorf("non-descendant %s leaked into --parent result", outside.ID)
}
})
t.Run("label_filters_apply_to_external_only_rows", func(t *testing.T) {
t.Parallel()
p := newSharedProxiedProject(t, bd, "bkl")
// A row blocked only by an unsatisfied external ref is listed by the
// unit-of-work decorator after the label query ran, so the filters
// must judge it by its own labels, read hydrated.
tagged := bdProxiedCreate(t, bd, p.dir, "Externally blocked, labelled", "-l", "lane:a")
bare := bdProxiedCreate(t, bd, p.dir, "Externally blocked, unlabelled")
for _, id := range []string{tagged.ID, bare.ID} {
if _, stderr, err := bdProxiedRunBuffers(t, bd, p.dir, "dep", "add", id, "external:otherproj:cap"); err != nil {
t.Fatalf("dep add %s external: %v\n%s", id, err, stderr)
}
}
for _, tc := range []struct {
args []string
want []string
}{
{nil, []string{tagged.ID, bare.ID}},
{[]string{"--label", "lane:a"}, []string{tagged.ID}},
{[]string{"--label-any", "lane:a"}, []string{tagged.ID}},
{[]string{"--exclude-label", "lane:a"}, []string{bare.ID}},
} {
got := bdProxiedBlockedJSON(t, bd, p, tc.args...)
ids := make([]string, 0, len(got))
for _, bi := range got {
ids = append(ids, bi.ID)
if bi.ID == tagged.ID && !slices.Equal(bi.Labels, []string{"lane:a"}) {
t.Errorf("bd blocked %v: %s prints labels %v, want [lane:a]", tc.args, bi.ID, bi.Labels)
}
}
slices.Sort(ids)
slices.Sort(tc.want)
if !slices.Equal(ids, tc.want) {
t.Errorf("bd blocked %v listed %v, want %v", tc.args, ids, tc.want)
}
}
})
}

View file

@ -207,12 +207,6 @@ Examples:
}
if beadsDir == "" {
// Discovery passes over a .beads marked only by a legacy
// config.json. One in a format this build cannot open is refused
// as that, not reported as no workspace.
if err := checkUndiscoveredWorkspaceFormat(); err != nil {
return handleWorkspaceGuardError(err)
}
if jsonOutput {
if err := outputJSON(noWorkspaceBootstrapPayload()); err != nil {
return err
@ -225,7 +219,7 @@ Examples:
}
if err := guardLegacyUpgradeWorkspace(beadsDir); err != nil {
return handleWorkspaceGuardError(err)
return HandleError("%v", err)
}
// Load config from .beads/metadata.json. When the beadsDir was
@ -240,9 +234,7 @@ Examples:
}
if cfg == nil {
cfg, err = findParentConfig(beadsDir)
if isUnsupportedWorkspaceFormat(err) {
return handleWorkspaceGuardError(err)
} else if err != nil {
if err != nil {
return HandleError("failed to load ancestor storage metadata: %v; no storage database was opened or modified; fix or restore metadata.json and retry", err)
}
}
@ -282,11 +274,7 @@ Examples:
}
if err := executeBootstrapPlan(plan, cfg, nonInteractive); err != nil {
// The error can carry sync.remote verbatim, credentials and all:
// sanitizeURL passes through a URL net/url cannot parse (a
// password with an unencoded "#" or "?"), and Dolt's "invalid
// remote url:" repeats it. Scrub it where it is printed.
return HandleError("Bootstrap failed: %s", scrubURLCredentials(err.Error()))
return HandleError("Bootstrap failed: %v", err)
}
return nil
},
@ -1594,9 +1582,6 @@ func isNonInteractiveBootstrap(flagValue bool) bool {
// parent workspace does. Returns nil if no parent config is found. A malformed
// or unreadable ancestor metadata file is authoritative and returned as an error;
// bootstrap must not skip it and select a more distant workspace or defaults.
// An ancestor holding the graph format marker without metadata it can read is
// a graph workspace, refused like one whose metadata declares graph_mode,
// rather than skipped or reported as a metadata load failure.
func findParentConfig(beadsDir string) (*configfile.Config, error) {
// Start from the parent of beadsDir's enclosing directory.
// beadsDir is typically "<project>/.beads", so we start from <project>'s parent.
@ -1614,9 +1599,6 @@ func findParentConfig(beadsDir string) (*configfile.Config, error) {
for dir, ok := walk.Next(); ok; dir, ok = walk.Next() {
candidate := filepath.Join(dir, ".beads")
cfg, err := configfile.LoadForDiscovery(candidate)
if (err != nil || cfg == nil) && hasGraphFormatMarker(candidate) {
return nil, &configfile.UnsupportedWorkspaceFormatError{BeadsDir: candidate, FormatMarker: true}
}
if err != nil {
return nil, fmt.Errorf("%s: %w", configfile.ConfigPath(candidate), err)
}
@ -1674,31 +1656,25 @@ func isGitCodeRepoURL(rawURL string) bool {
// urlHostname extracts the lowercase hostname from a URL without importing
// net/url. Handles scheme://[user@]host[:port]/path and SCP git@host:path.
//
// The host part is cut out before userinfo is stripped through its last "@",
// so an "@" in a path, query or fragment never selects the host (mc-gcmer).
// For a scheme URL the host part is the authority, which ends at the first
// "/", "?" or "#" — the host net/url, and so Dolt, would dial. For SCP it is
// everything before the first ":", unless a "/" comes first, which makes it a
// local path (the split doltremote.FromGitURL makes).
func urlHostname(rawURL string) string {
if sep := strings.Index(rawURL, "://"); sep >= 0 {
rest := rawURL[sep+3:]
if end := strings.IndexAny(rest, "/?#"); end >= 0 {
rest = rest[:end]
}
if at := strings.LastIndex(rest, "@"); at >= 0 {
if at := strings.Index(rest, "@"); at >= 0 {
rest = rest[at+1:]
}
if slash := strings.Index(rest, "/"); slash >= 0 {
rest = rest[:slash]
}
if colon := strings.Index(rest, ":"); colon >= 0 {
rest = rest[:colon]
}
return strings.ToLower(rest)
}
// SCP-style: git@github.com:org/repo
if colon := strings.Index(rawURL, ":"); colon >= 0 && !strings.Contains(rawURL[:colon], "/") {
if at := strings.LastIndex(rawURL[:colon], "@"); at >= 0 {
return strings.ToLower(rawURL[at+1 : colon])
if at := strings.Index(rawURL, "@"); at >= 0 {
rest := rawURL[at+1:]
if colon := strings.Index(rest, ":"); colon >= 0 {
return strings.ToLower(rest[:colon])
}
}
return ""

View file

@ -295,49 +295,3 @@ func TestEmbeddedBootstrapConcurrent(t *testing.T) {
}
}
}
// TestEmbeddedBootstrapCloneFailureScrubsCredentials pins the credential scrub
// at the "Bootstrap failed:" print site (mc-gcmer). An unencoded "#" or "?" in
// the password ends the URL's authority early, so the remote is not a forge
// and is cloned as configured. The clone error then carries the password
// twice: sanitizeURL passes a URL net/url cannot parse through unchanged, and
// Dolt's "invalid remote url:" repeats it.
func TestEmbeddedBootstrapCloneFailureScrubsCredentials(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
for _, tc := range []struct{ name, password string }{
{"hash", "pa#ss"},
{"question_mark", "pa?ss"},
} {
t.Run(tc.name, func(t *testing.T) {
dir := t.TempDir()
initGitRepoAt(t, dir)
beadsDir := filepath.Join(dir, ".beads")
if err := os.MkdirAll(beadsDir, 0o750); err != nil {
t.Fatalf("mkdir .beads: %v", err)
}
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte("{}"), 0o644); err != nil {
t.Fatalf("write metadata.json: %v", err)
}
seedSyncRemote(t, beadsDir, "https://alice:"+tc.password+"@github.com/org/db")
cmd := exec.Command(bd, "bootstrap", "--yes")
cmd.Dir = dir
cmd.Env = bdEnv(dir)
stdout, stderr, err := runCommandBuffers(t, cmd)
// A failure before the clone would pass the leak check below
// without reaching the print site.
if err == nil || !strings.Contains(stderr.String(), "Bootstrap failed: clone from remote:") {
t.Fatalf("bootstrap should fail at the clone, got err=%v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
}
if strings.Contains(stdout.String()+stderr.String(), tc.password) {
t.Errorf("bootstrap printed the sync.remote password %q:\nstdout:\n%s\nstderr:\n%s", tc.password, stdout.String(), stderr.String())
}
})
}
}

View file

@ -60,21 +60,6 @@ func TestIsGitCodeRepoURL(t *testing.T) {
// SCP-style to non-forge — allowed
{"git@my-dolt.example.com:org/db", false},
// Userinfo before a forge host is stripped, in either URL form
{"ssh://git@github.com/org/db", true},
{"https://x-access-token:secret@github.com/org/db", true},
{"git@github.com:org/db", true},
// ...through the last "@" of the host part, as net/url (and so Dolt) reads it
{"https://a@b@github.com/org/db", true},
{"a@b@github.com:org/db", true},
// An "@" outside the host part never selects the host (mc-gcmer)
{"https://my-dolt.example.com/x@github.com/path", false},
{"https://my-dolt.example.com?x@github.com", false},
{"https://my-dolt.example.com#x@github.com", false},
{"my-dolt.example.com:org/x@github.com:db", false},
{"./backups/me@github.com:db", false},
// Edge: empty string
{"", false},
}
@ -136,9 +121,6 @@ var forgeSyncRemoteForms = []struct {
{"already git+https", "git+https://github.com/org/repo.git", "git+https://github.com/org/repo.git"},
{"git+ssh without user", "git+ssh://github.com/org/repo.git", "git+ssh://github.com/org/repo.git"},
{"gitlab", "https://gitlab.com/group/repo.git", "git+https://gitlab.com/group/repo.git"},
// No .git suffix, so only the host can make it a forge: github.com, after
// the last "@" of the authority (mc-gcmer).
{"multi-@ userinfo", "https://a@b@github.com/org/repo", "git+https://a@b@github.com/org/repo"},
}
// newForgeSyncRemoteWorkspace builds a workspace whose config.yaml carries

View file

@ -79,9 +79,6 @@ const (
trackSync = "proxied-parity S5 (bd sync)"
trackDegradation = "proxied-parity S6 (doctor, config show, degradations)"
trackLongTail = "proxied-parity S7 (long-tail policy pass)"
// Versioned history (gastownhall/beads#6132) is not a proxied-parity slice:
// its reads need a storage.VersionLister over the proxied uow provider.
trackVersionedHistory = "versioned history: VersionLister over the proxied uow provider (gastownhall/beads#6132)"
)
// capabilityRow is one command-path policy row. ArgSet is the sorted set of
@ -454,16 +451,6 @@ var proxyCapabilityRegistry = []capabilityRow{
// at the front door would leave those modes with no way to flush.
permitted("dolt commit").withHistory(HistoryProxySupported),
// --- versioned history ----------------------------------------------------
// `bd versions` is a pure read (issueops.ListVersionsInTx in one read
// transaction), so nothing about it is unsafe on a shared backend. It is
// refused only because no proxied route exists yet: it reaches the backend
// through the optional storage.VersionLister, which the dolt and embedded
// stores implement and the uow provider does not. Permitting it would open
// the proxied provider in the root pre-run and then fail untyped at
// errVersionsUnsupported, so it is refused here, before any side effect.
refusedPath("versions", "proxy.versions.unsupported", ProxyReasonUnimplemented, trackVersionedHistory),
// --- untyped refusals inside RunE ---------------------------------------
// The gate permits these paths and the command refuses itself with a bare
// string, so a JSON consumer gets no code and no mutates flag. They are

View file

@ -872,12 +872,10 @@ func resolveReasonFile(cmd *cobra.Command, hasExistingReason bool) (string, bool
// resolveCloseTargets resolves a batch of partial issue IDs for `bd close`,
// preserving input order. For each ID it tries the local store first, then
// explicit prefix routing via routes.jsonl, then a shared auto-routed store.
// This matches resolveAndGetIssueForMutation's routing precedence and write
// intent, and like it returns a routing failure (an unreadable routes.jsonl, a
// routed store that fails to open) as itself rather than as a not-found.
// explicit prefix routing via routes.jsonl, then a shared contributor-routed
// store. This matches resolveAndGetIssueWithRouting's routing precedence.
//
// The auto-routed handle is shared across the batch so bulk close does
// The contributor-routed handle is shared across the batch so bulk close does
// not repeatedly open the same planning store and every result has a clear store
// owner for subsequent close-time checks and writes.
//
@ -886,92 +884,60 @@ func resolveReasonFile(cmd *cobra.Command, hasExistingReason bool) (string, bool
// no-op for routed-via-shared-handle entries because they don't own the handle.
func resolveCloseTargets(ctx context.Context, localStore storage.DoltStorage, ids []string) ([]*RoutedResult, func(), error) {
results := make([]*RoutedResult, 0, len(ids))
shared := &closeAutoRoute{localStore: localStore}
var sharedRouted storage.DoltStorage
var sharedRoutedTried bool
cleanup := func() {
for _, r := range results {
r.Close()
}
shared.Close()
if sharedRouted != nil {
_ = sharedRouted.Close()
}
}
ensureShared := func() (storage.DoltStorage, error) {
if sharedRouted != nil {
return sharedRouted, nil
}
if sharedRoutedTried {
return nil, fmt.Errorf("no auto-routed store available")
}
sharedRoutedTried = true
rs, routed, _, err := openRoutedReadStore(ctx, localStore)
if err != nil {
return nil, err
}
if !routed {
return nil, fmt.Errorf("no auto-routed store available")
}
sharedRouted = rs
return rs, nil
}
for _, id := range ids {
r, err := resolveCloseTarget(ctx, localStore, shared, id)
if err != nil {
// Local first.
if r, err := resolveAndGetFromStore(ctx, localStore, id, false); err == nil {
results = append(results, r)
continue
} else if !isNotFoundErr(err) {
cleanup()
return nil, func() {}, err
return nil, func() {}, fmt.Errorf("resolving ID %s: %w", id, err)
}
results = append(results, r)
// Write-intent: a prefix-routed target opens writable so the close
// commits on the target head (#4141). Contributor auto-routing below
// stays read-only: it hydrates foreign projects that must not be mutated.
if r, err := resolveViaPrefixRoutingWithAccess(ctx, id, true, false); err == nil {
results = append(results, r)
continue
}
// Contributor auto-routing uses one shared store for the whole batch.
if rs, rerr := ensureShared(); rerr == nil {
if r, err := resolveAndGetFromStore(ctx, rs, id, true); err == nil {
// Per-id RoutedResult does not own the shared handle; cleanup() does.
results = append(results, r)
continue
}
}
cleanup()
return nil, func() {}, fmt.Errorf("resolving ID %s: no issue found matching %q", id, id)
}
return results, cleanup, nil
}
// resolveCloseTarget resolves one ID of a bd close batch: the local store,
// then a prefix route, then the batch's shared auto-routed store.
func resolveCloseTarget(ctx context.Context, localStore storage.DoltStorage, shared *closeAutoRoute, id string) (*RoutedResult, error) {
// Local first.
r, err := resolveAndGetFromStore(ctx, localStore, id, false)
if err == nil {
return r, nil
}
if !isNotFoundErr(err) {
return nil, fmt.Errorf("resolving ID %s: %w", id, err)
}
// Write-intent: a prefix-routed target opens writable so the close
// commits on the target head (#4141).
r, err = resolveViaPrefixRoutingWithAccess(ctx, id, true, false)
if err == nil {
return r, nil
}
if isRoutingFailure(err) {
return nil, fmt.Errorf("resolving ID %s: %w", id, err)
}
r, err = shared.resolve(ctx, id)
if err == nil {
return r, nil
}
if isRoutingFailure(err) {
return nil, fmt.Errorf("resolving ID %s: %w", id, err)
}
return nil, fmt.Errorf("resolving ID %s: no issue found matching %q", id, id)
}
// closeAutoRoute is the auto-routed store a bd close batch shares. It opens on
// first use and is closed once, by the batch's cleanup.
type closeAutoRoute struct {
localStore storage.DoltStorage
store storage.DoltStorage
err error
tried bool
}
// resolve looks id up in the shared auto-routed store, opening it on the first
// call with write intent, as resolveAndGetIssueForMutation does: the target
// opens writable, whichever rule selected it, so the close commits where the
// issue lives. The outcome of that open, failure included, holds for the rest
// of the batch.
func (a *closeAutoRoute) resolve(ctx context.Context, id string) (*RoutedResult, error) {
if !a.tried {
a.tried = true
rs, routed, _, err := openAutoRoutedStore(ctx, a.localStore, true)
switch {
case err != nil:
a.err = err
case !routed:
a.err = fmt.Errorf("%w: no auto-routed store available", errRoutingUnavailable)
default:
a.store = rs
}
}
if a.err != nil {
return nil, a.err
}
// Per-id RoutedResult does not own the shared handle; Close does.
return resolveAndGetFromStore(ctx, a.store, id, true)
}
// Close closes the shared auto-routed store, if one was opened.
func (a *closeAutoRoute) Close() {
if a.store != nil {
_ = a.store.Close()
a.store = nil
}
}

View file

@ -10,7 +10,7 @@ import (
"github.com/steveyegge/beads/internal/types"
)
// TestEmbeddedIfRevisionCloseReplaysMoleculeAutoClose pins mc-zndi7.75 item 1 on the
// TestIfRevisionCloseReplaysMoleculeAutoClose pins mc-zndi7.75 item 1 on the
// embedded/direct --if-revision close route: runCloseDirectIfRevision bypasses
// `bd close`'s batch architecture entirely (A8, beads#4682 — BatchCloseItem
// carries no per-item ExpectedVersion), so it must re-drive molecule auto-close
@ -22,7 +22,7 @@ import (
// state a crash between the final step's close and its root auto-close would
// leave), then re-close the final step — this time guarded — and require the
// stranded-open root to heal.
func TestEmbeddedIfRevisionCloseReplaysMoleculeAutoClose(t *testing.T) {
func TestIfRevisionCloseReplaysMoleculeAutoClose(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -60,12 +60,12 @@ func TestEmbeddedIfRevisionCloseReplaysMoleculeAutoClose(t *testing.T) {
}
}
// TestEmbeddedIfRevisionCloseWarnsOnForcedOpenChildren pins mc-zndi7.75 item 3: the
// TestIfRevisionCloseWarnsOnForcedOpenChildren pins mc-zndi7.75 item 3: the
// "warning: closing X with N open child issue(s) still active" line
// (close.go:194-196) must still print on the guarded direct close route when
// --force waives the engine's open-children refusal, exactly as it does on
// the unguarded batch path.
func TestEmbeddedIfRevisionCloseWarnsOnForcedOpenChildren(t *testing.T) {
func TestIfRevisionCloseWarnsOnForcedOpenChildren(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -10,7 +10,7 @@ import (
)
// TestProxiedServerIfRevisionCloseReplaysMoleculeAutoClose is
// TestEmbeddedIfRevisionCloseReplaysMoleculeAutoClose's proxied-server twin, pinning
// TestIfRevisionCloseReplaysMoleculeAutoClose's proxied-server twin, pinning
// mc-zndi7.75 item 1 on the route `bd serve` actually runs:
// runCloseProxiedIfRevision bypasses the batch entirely (A8, beads#4682), so
// it must re-drive molecule auto-close itself via its own post-close unit of
@ -53,7 +53,7 @@ func TestProxiedServerIfRevisionCloseReplaysMoleculeAutoClose(t *testing.T) {
}
// TestProxiedServerIfRevisionCloseWarnsOnForcedOpenChildren is
// TestEmbeddedIfRevisionCloseWarnsOnForcedOpenChildren's proxied-server twin, pinning
// TestIfRevisionCloseWarnsOnForcedOpenChildren's proxied-server twin, pinning
// mc-zndi7.75 item 3 on the proxied route.
func TestProxiedServerIfRevisionCloseWarnsOnForcedOpenChildren(t *testing.T) {
requireSharedProxiedServer(t)

View file

@ -69,7 +69,6 @@ func TestResolveCloseTargets(t *testing.T) {
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
initConfigForTest(t)
neutralizeRoutingModeEnv(t)
tmpDir := t.TempDir()
repoDir := filepath.Join(tmpDir, "repo")

View file

@ -1,444 +0,0 @@
//go:build cgo
// cgo only: the goldens pin the cgo build, which every lane that runs this
// package's full suite compiles. The !cgo build replaces the federation
// subtree with a one-command stub (federation_nocgo.go), so its tree differs
// by design.
package main
import (
"bytes"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
"testing"
"github.com/charmbracelet/x/ansi"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)
// The committed command-surface goldens. Regenerate after an intentional CLI
// change, then review the diff like code:
//
// BD_UPDATE_GOLDEN=1 CGO_ENABLED=1 go test -tags gms_pure_go ./cmd/bd -run '^TestCommand(Tree|Help)Golden$'
//
// CGO_ENABLED=1 because this file builds only with cgo: with cgo off the
// command matches no test, exits 0 and leaves the goldens as they were.
const (
commandTreeGoldenPath = "testdata/command_tree/tree.golden"
commandHelpGoldenDir = "testdata/command_tree/help"
commandGoldenRegen = "BD_UPDATE_GOLDEN=1 CGO_ENABLED=1 go test -tags gms_pure_go ./cmd/bd -run '^TestCommand(Tree|Help)Golden$'"
)
// commandHelpGoldenArgs is the representative set of commands whose exact
// --help output is pinned, each as the argv after "bd". The tree golden
// covers every command's metadata; these cover the rendering (usage line,
// flag table layout, inherited global flags, root command groups).
var commandHelpGoldenArgs = [][]string{
{},
{"create"},
{"show"},
{"list"},
{"update"},
{"close"},
{"version"},
{"versions"},
{"config"},
{"serve"},
}
// TestCommandTreeGolden pins the whole bd command tree: for every command and
// subcommand, hidden ones included, its Use, Aliases, Short, Long, Example,
// group, hidden/deprecated state, runnability and annotations, and every
// local and persistent flag it defines (name, shorthand, type, default,
// usage, hidden, deprecation, annotations). Any added, removed or reworded
// command or flag fails this test until the golden is regenerated, so the
// change shows up as a reviewed testdata diff. It reads the in-memory tree
// only: no store or subprocess.
//
// docs/cli-docs.pin pins the generated CLI reference (and check-doc-flags)
// to a release, so drift on main is not caught there; this golden is the
// live guard for the command surface.
func TestCommandTreeGolden(t *testing.T) {
pkgDir := enterOrdinaryWorkspaceForGolden(t)
primeCommandTreeForGolden()
flagCounts := commandFlagCounts(rootCmd)
got := renderCommandTreeGolden(rootCmd)
// A renderer that iterated a map would pass on the run that regenerated
// the golden and flake afterwards.
if again := renderCommandTreeGolden(rootCmd); again != got {
t.Fatalf("command tree rendering is not deterministic:\n%s", goldenLineDiff(got, again))
}
// Nor may rendering change the tree it reads: tests sharing this binary
// pin a command's exact flag set (TestServeFlags). See goldenLocalFlags.
if after := commandFlagCounts(rootCmd); after != flagCounts {
t.Fatalf("rendering the command tree added flags to a command's own flag set:\n%s", goldenLineDiff(flagCounts, after))
}
checkCommandGolden(t, pkgDir, commandTreeGoldenPath, got)
}
// TestCommandHelpGolden pins the exact `bd <command> --help` output of a
// representative set of commands, executed in-process through the real root
// command. --help returns before the root pre-run, so no store is opened.
// Color escapes are stripped so the snapshot is independent of terminal
// detection; otherwise the snapshots are byte-identical to what a built bd
// prints.
func TestCommandHelpGolden(t *testing.T) {
pkgDir := enterOrdinaryWorkspaceForGolden(t)
// Parsing `bd serve --help` merges the root's persistent flags into
// serveCmd's own flag set, which TestServeFlags pins; restoreServeGlobals
// re-registers that set afterwards.
restoreServeGlobals(t)
want := map[string]bool{}
for _, args := range commandHelpGoldenArgs {
name := strings.Join(append([]string{"bd"}, args...), "_")
file := name + ".golden"
want[file] = true
t.Run(name, func(t *testing.T) {
checkCommandGolden(t, pkgDir, filepath.Join(commandHelpGoldenDir, file), renderCommandHelpGolden(t, args))
})
}
// The directory holds exactly the listed snapshots: a command dropped
// from the list must not leave a stale file that still looks pinned.
dir := filepath.Join(pkgDir, commandHelpGoldenDir)
entries, err := os.ReadDir(dir)
if err != nil {
t.Fatalf("read %s: %v", commandHelpGoldenDir, err)
}
for _, e := range entries {
if want[e.Name()] {
continue
}
if os.Getenv("BD_UPDATE_GOLDEN") == "1" {
if err := os.Remove(filepath.Join(dir, e.Name())); err != nil {
t.Fatalf("remove stale help golden %s: %v", e.Name(), err)
}
t.Logf("removed stale help golden %s", e.Name())
continue
}
t.Errorf("%s/%s is not in commandHelpGoldenArgs; delete it or regenerate with %s", commandHelpGoldenDir, e.Name(), commandGoldenRegen)
}
}
// enterOrdinaryWorkspaceForGolden moves the test into a fresh ordinary
// (dependency-mode) workspace: a .beads/metadata.json with no graph marker
// and no database behind it, so nothing can be read from or written to a
// store. It returns the package directory, where the goldens live.
func enterOrdinaryWorkspaceForGolden(t *testing.T) string {
t.Helper()
isolateBeadsDirForTest(t)
pkgDir, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
ws := t.TempDir()
beadsDir := filepath.Join(ws, ".beads")
if err := os.Mkdir(beadsDir, 0o750); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(beadsDir, "metadata.json"), []byte(`{"backend":"dolt"}`), 0o600); err != nil {
t.Fatal(err)
}
t.Chdir(ws)
return pkgDir
}
// primeCommandTreeForGolden completes the tree the way the bd binary does
// before it dispatches: main() adds cobra's help command and its
// --all/--doc/--list/--docs-root flags, and ExecuteC adds the completion
// command. All three are idempotent, so the tree is the same whether or not
// an earlier in-process test already executed rootCmd.
func primeCommandTreeForGolden() {
rootCmd.InitDefaultHelpCmd()
registerHelpAllFlag()
rootCmd.InitDefaultCompletionCmd()
}
// renderCommandTreeGolden walks cmd's tree depth first, children sorted by
// name, and renders one block per command.
func renderCommandTreeGolden(root *cobra.Command) string {
var b strings.Builder
b.WriteString("# bd command tree (cgo build), pinned by TestCommandTreeGolden.\n")
b.WriteString("# Regenerate after an intentional CLI change:\n")
b.WriteString("# " + commandGoldenRegen + "\n")
var walk func(*cobra.Command)
walk = func(c *cobra.Command) {
writeCommandGoldenBlock(&b, c)
children := append([]*cobra.Command(nil), c.Commands()...)
sort.Slice(children, func(i, j int) bool { return children[i].Name() < children[j].Name() })
for _, sub := range children {
// cobra adds the hidden shell-completion request commands only
// for an execution that invokes them, and then never removes
// them: whether they are present depends on test history, not
// on the bd surface.
if sub.Name() == cobra.ShellCompRequestCmd || sub.Name() == cobra.ShellCompNoDescRequestCmd {
continue
}
walk(sub)
}
}
walk(root)
return b.String()
}
func writeCommandGoldenBlock(b *strings.Builder, c *cobra.Command) {
fmt.Fprintf(b, "\n%s\n", c.CommandPath())
fmt.Fprintf(b, " use: %q\n", c.Use)
if len(c.Aliases) > 0 {
fmt.Fprintf(b, " aliases: %q\n", c.Aliases)
}
fmt.Fprintf(b, " short: %q\n", c.Short)
if c.GroupID != "" {
fmt.Fprintf(b, " group: %q\n", c.GroupID)
}
fmt.Fprintf(b, " hidden: %t\n", c.Hidden)
if c.Deprecated != "" {
fmt.Fprintf(b, " deprecated: %q\n", c.Deprecated)
}
fmt.Fprintf(b, " runnable: %t\n", c.Runnable())
if c.DisableFlagParsing {
b.WriteString(" disable-flag-parsing: true\n")
}
if len(c.ValidArgs) > 0 {
fmt.Fprintf(b, " valid-args: %q\n", c.ValidArgs)
}
if len(c.Annotations) > 0 {
fmt.Fprintf(b, " annotations: %s\n", formatGoldenAnnotations(c.Annotations))
}
writeGoldenTextBlock(b, "long", c.Long)
writeGoldenTextBlock(b, "example", c.Example)
for _, line := range commandGoldenFlagLines(c.PersistentFlags()) {
fmt.Fprintf(b, " persistent-flag %s\n", line)
}
for _, line := range commandGoldenFlagLines(goldenLocalFlags(c)) {
fmt.Fprintf(b, " flag %s\n", line)
}
}
// goldenLocalFlags returns the non-persistent flags c registers itself,
// including any that shadow an inherited flag: the set
// c.LocalNonPersistentFlags() reports, read without calling it. That
// accessor, like LocalFlags and InheritedFlags, runs cobra's
// mergePersistentFlags, which copies every inherited persistent flag into
// c.Flags() for the rest of the process. Over the whole tree that would leave
// `bd serve` carrying the root's --json, --db and the rest, and break
// TestServeFlags (see TestNoSubcommandShadowsRootJSONFlag).
//
// c.Flags() may already hold such copies from an earlier in-process
// execution. They are recognized by identity, the way cobra itself tells
// them apart: an inherited flag is the nearest ancestor's own *pflag.Flag of
// that name, and a shadowing flag is a different one.
func goldenLocalFlags(c *cobra.Command) *pflag.FlagSet {
local := pflag.NewFlagSet(c.Name(), pflag.ContinueOnError)
c.Flags().VisitAll(func(f *pflag.Flag) {
if c.PersistentFlags().Lookup(f.Name) != nil {
return // rendered as a persistent-flag line
}
for p := c.Parent(); p != nil; p = p.Parent() {
if inherited := p.PersistentFlags().Lookup(f.Name); inherited != nil {
if inherited == f {
return
}
break
}
}
local.AddFlag(f)
})
return local
}
// commandFlagCounts renders how many flags each command's own flag set holds,
// one line per command, read without merging anything into it.
func commandFlagCounts(root *cobra.Command) string {
var b strings.Builder
var walk func(*cobra.Command)
walk = func(c *cobra.Command) {
n := 0
c.Flags().VisitAll(func(*pflag.Flag) { n++ })
fmt.Fprintf(&b, "%s %d\n", c.CommandPath(), n)
for _, sub := range c.Commands() {
walk(sub)
}
}
walk(root)
return b.String()
}
// writeGoldenTextBlock writes a multi-line field one source line per golden
// line, behind a "|" gutter so leading whitespace and blank lines survive.
func writeGoldenTextBlock(b *strings.Builder, name, text string) {
if text == "" {
return
}
fmt.Fprintf(b, " %s:\n", name)
for _, line := range strings.Split(text, "\n") {
if line == "" {
b.WriteString(" |\n")
continue
}
fmt.Fprintf(b, " | %s\n", line)
}
}
// commandGoldenFlagLines renders each flag of fs on one line, sorted by name.
// cobra's own lazily added --help flag (FlagSetByCobraAnnotation) is skipped:
// it exists only on commands an earlier in-process execution reached.
func commandGoldenFlagLines(fs *pflag.FlagSet) []string {
var flags []*pflag.Flag
fs.VisitAll(func(f *pflag.Flag) {
if _, byCobra := f.Annotations[cobra.FlagSetByCobraAnnotation]; byCobra {
return
}
flags = append(flags, f)
})
sort.Slice(flags, func(i, j int) bool { return flags[i].Name < flags[j].Name })
lines := make([]string, 0, len(flags))
for _, f := range flags {
var b strings.Builder
fmt.Fprintf(&b, "--%s", f.Name)
if f.Shorthand != "" {
fmt.Fprintf(&b, " -%s", f.Shorthand)
}
fmt.Fprintf(&b, " type=%s default=%q", f.Value.Type(), f.DefValue)
if f.NoOptDefVal != "" && !implicitNoOptDefault(f) {
fmt.Fprintf(&b, " no-opt-default=%q", f.NoOptDefVal)
}
if f.Hidden {
b.WriteString(" hidden")
}
if f.Deprecated != "" {
fmt.Fprintf(&b, " deprecated=%q", f.Deprecated)
}
if f.ShorthandDeprecated != "" {
fmt.Fprintf(&b, " shorthand-deprecated=%q", f.ShorthandDeprecated)
}
if len(f.Annotations) > 0 {
fmt.Fprintf(&b, " annotations=%s", formatGoldenAnnotations(f.Annotations))
}
fmt.Fprintf(&b, " usage=%q", f.Usage)
lines = append(lines, b.String())
}
return lines
}
// implicitNoOptDefault reports whether f's NoOptDefVal is the one pflag gives
// every flag of its type (a bare --bool means true, a bare --count adds one),
// which would only repeat the type on each line.
func implicitNoOptDefault(f *pflag.Flag) bool {
switch f.Value.Type() {
case "bool":
return f.NoOptDefVal == "true"
case "count":
return f.NoOptDefVal == "+1"
}
return false
}
// formatGoldenAnnotations renders a command's or a flag's annotations sorted
// by key.
func formatGoldenAnnotations[V string | []string](m map[string]V) string {
keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
sort.Strings(keys)
parts := make([]string, 0, len(keys))
for _, k := range keys {
parts = append(parts, fmt.Sprintf("%s=%q", k, m[k]))
}
return "{" + strings.Join(parts, " ") + "}"
}
// renderCommandHelpGolden runs `bd <args> --help` through rootCmd in-process
// and returns its stdout with color escapes stripped. cobra keeps the parsed
// --help value on the shared tree, so every flag is put back afterwards: a
// later in-process `bd create ...` must not print help instead.
//
// internal/ui decides color once, at init, from CLICOLOR_FORCE and whether the
// test binary's stdout is a terminal. CI never gives it one, so there the
// strip removes nothing; it is what keeps a run from a terminal matching the
// goldens.
func renderCommandHelpGolden(t *testing.T, args []string) string {
t.Helper()
argv := append(append([]string(nil), args...), "--help")
primeCommandTreeForGolden()
var execErr error
out := captureStdout(t, func() error {
rootCmd.SetArgs(argv)
defer rootCmd.SetArgs(nil)
defer resetCommandFlags(rootCmd)
_, execErr = rootCmd.ExecuteC()
return nil
})
if execErr != nil {
t.Fatalf("bd %s: %v", strings.Join(argv, " "), execErr)
}
return ansi.Strip(out)
}
// checkCommandGolden compares got with the golden at rel under pkgDir, or
// rewrites the golden when BD_UPDATE_GOLDEN=1 (the package's shared golden
// switch).
func checkCommandGolden(t *testing.T, pkgDir, rel, got string) {
t.Helper()
path := filepath.Join(pkgDir, rel)
if os.Getenv("BD_UPDATE_GOLDEN") == "1" {
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
t.Fatalf("mkdir %s: %v", filepath.Dir(rel), err)
}
if err := os.WriteFile(path, []byte(got), 0o644); err != nil {
t.Fatalf("write golden %s: %v", rel, err)
}
t.Logf("updated golden %s", rel)
return
}
want, err := os.ReadFile(path)
if err != nil {
t.Fatalf("read golden %s (regenerate with %s): %v", rel, commandGoldenRegen, err)
}
if bytes.Equal([]byte(got), want) {
return
}
t.Errorf("bd command surface drifted from %s.\n%s\nIf the change is intended, regenerate with\n %s\nand review the testdata diff.",
rel, goldenLineDiff(string(want), got), commandGoldenRegen)
}
// goldenLineDiff reports the region where want and got differ: the common
// leading and trailing lines are trimmed and the rest is shown as -/+ lines,
// capped so a large drift stays readable (the reviewed artifact is the
// regenerated testdata diff, not this message).
func goldenLineDiff(want, got string) string {
const maxLines = 40
w := strings.Split(want, "\n")
g := strings.Split(got, "\n")
pre := 0
for pre < len(w) && pre < len(g) && w[pre] == g[pre] {
pre++
}
suf := 0
for suf < len(w)-pre && suf < len(g)-pre && w[len(w)-1-suf] == g[len(g)-1-suf] {
suf++
}
var b strings.Builder
fmt.Fprintf(&b, "first difference at line %d:\n", pre+1)
write := func(sign string, lines []string) {
for i, line := range lines {
if i == maxLines {
fmt.Fprintf(&b, "%s ... (%d more lines)\n", sign, len(lines)-maxLines)
return
}
fmt.Fprintf(&b, "%s %s\n", sign, line)
}
}
write("-", w[pre:len(w)-suf])
write("+", g[pre:len(g)-suf])
return b.String()
}

View file

@ -280,12 +280,6 @@ var configSetCmd = &cobra.Command{
if err != nil {
return HandleError("%v", err)
}
// Per-key validation that needs the store rather than the key alone: turning
// versioned history on refuses, writing nothing, while any issue holds a value a
// version could not record. The store is open here, on whichever route this is.
if err := checkVersionedHistoryCanBeEnabled(rootCtx, key, value); err != nil {
return HandleError("%v", err)
}
result, err := settings.SetSetting(rootCtx, issueops.SetSettingRequest{Key: key, Value: value})
if err != nil {
return HandleError("setting config: %v", err)
@ -1228,14 +1222,6 @@ Examples:
return HandleError("%v", err)
}
}
// The pre-enable check `bd config set` makes: turning versioned history
// on refuses while any issue holds a value a version could not record.
// This verb writes the same setting through a loop of its own, so it
// makes the check itself, here and before any pair is written: a refusal
// stores nothing from the batch.
if err := checkVersionedHistoryCanBeEnabled(rootCtx, p.key, p.value); err != nil {
return HandleError("%v", err)
}
}
var yamlPairs, gitPairs, dbPairs []kvPair
@ -1366,7 +1352,7 @@ var recognizedConfigPrefixes = []string{
"status.", "types.", "doctor.suppress.", "routing.", "sync.", "git.",
"directory.", "repos.", "external_projects.", "validation.",
"lint.", "hierarchy.", "ai.", "backup.", "federation.", "metrics.",
"agent.", "claim.", "storage-class.", "versioned-history.",
"agent.", "claim.", "storage-class.",
}
// validateStorageClassConfig validates a storage-class.<type> per-type

View file

@ -193,52 +193,32 @@ func TestApplyServerSkipsWhenAutoStartDisabled(t *testing.T) {
}
}
// isolatedApplyFixture builds a throwaway git repo with a .beads dir for the
// runApply tests. runApply(false) is a live apply: it inspects AND MUTATES the
// repository that owns the process cwd (hook reinstalls, hooksPath mkdirs).
// Run bare from the package dir, that repository is this checkout — the r880
// host .git clobber (wy-qlvlmf) — so these tests must always chdir into a
// fixture they own first.
func isolatedApplyFixture(t *testing.T) string {
t.Helper()
dir := t.TempDir()
initGitRepoAt(t, dir)
if err := os.MkdirAll(filepath.Join(dir, ".beads"), 0o755); err != nil {
t.Fatalf("create fixture .beads: %v", err)
}
return dir
}
func TestRunApplyAllOK(t *testing.T) {
t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1")
runInDir(t, isolatedApplyFixture(t), func() {
// In a test environment with no drift, all results should be ok or skipped
results := runApply(false)
if len(results) != 3 {
t.Errorf("expected 3 results, got %d", len(results))
// In a test environment with no drift, all results should be ok or skipped
results := runApply(false)
if len(results) != 3 {
t.Errorf("expected 3 results, got %d", len(results))
}
for _, r := range results {
if r.Status == applyStatusError {
t.Errorf("unexpected error for check %q: %s", r.Check, r.Error)
}
for _, r := range results {
if r.Status == applyStatusError {
t.Errorf("unexpected error for check %q: %s", r.Check, r.Error)
}
}
})
}
}
func TestRunApplyDryRun(t *testing.T) {
t.Setenv("BEADS_TEST_IGNORE_REPO_CONFIG", "1")
runInDir(t, isolatedApplyFixture(t), func() {
results := runApply(true)
if len(results) != 3 {
t.Errorf("expected 3 results, got %d", len(results))
results := runApply(true)
if len(results) != 3 {
t.Errorf("expected 3 results, got %d", len(results))
}
// In dry-run, no actions should be "applied"
for _, r := range results {
if r.Status == applyStatusApplied {
t.Errorf("dry-run should not apply actions, but check %q was applied", r.Check)
}
// In dry-run, no actions should be "applied"
for _, r := range results {
if r.Status == applyStatusApplied {
t.Errorf("dry-run should not apply actions, but check %q was applied", r.Check)
}
}
})
}
}
func TestDriftDomainsGroupsDottedChecks(t *testing.T) {

View file

@ -4,8 +4,6 @@ import (
"fmt"
"os"
"strings"
"github.com/steveyegge/beads/internal/versionedhistory"
)
// configSideEffect describes a hint or warning to show after a config change.
@ -67,11 +65,6 @@ func checkConfigSetSideEffects(key, value string) []configSideEffect {
Message: fmt.Sprintf("Git sync remote set to %q. Ensure this git remote exists.", value),
Command: fmt.Sprintf("git remote -v | grep %s", value),
})
case key == versionedHistorySettingKey && versionedhistory.ValueEnables(value):
effects = append(effects, configSideEffect{
Message: "Versioned history now records for this store. The setting replicates on 'bd dolt push' and 'bd dolt pull', so every clone that pulls it records too, and it is safe with a single writer only: keep one writer at a time per store (docs/reference/configuration.md#versioned-issue-history).",
})
}
return effects

View file

@ -2,7 +2,6 @@ package main
import (
"os"
"strings"
"testing"
)
@ -106,34 +105,6 @@ func TestCheckConfigSetSideEffects_UnknownKey(t *testing.T) {
}
}
// versioned-history.enabled is a row of the store's config table, which
// replicates on `bd dolt push` and `bd dolt pull`, and the feature is single
// writer only. `bd config set ... true` is the moment someone turns it on, so it
// is where that caveat belongs -- said once, at the command that has the effect.
func TestVersionedHistoryConfigSetHintsAboutReplicationAndSingleWriter(t *testing.T) {
for _, on := range []string{"true", "TRUE", " true ", "1", "t"} {
effects := checkConfigSetSideEffects(versionedHistorySettingKey, on)
if len(effects) != 1 {
t.Errorf("value %q turns recording on: expected 1 hint, got %d", on, len(effects))
continue
}
for _, want := range []string{"replicates", "single writer"} {
if !strings.Contains(strings.ToLower(effects[0].Message), want) {
t.Errorf("value %q: the hint does not mention %q: %s", on, want, effects[0].Message)
}
}
}
// Turning it off, or anything that does not turn it on, needs no caveat.
for _, off := range []string{"false", "0", "", "off", "nonsense"} {
if effects := checkConfigSetSideEffects(versionedHistorySettingKey, off); len(effects) != 0 {
t.Errorf("value %q does not turn recording on: expected no hint, got %d", off, len(effects))
}
}
if effects := checkConfigUnsetSideEffects(versionedHistorySettingKey); len(effects) != 0 {
t.Errorf("unsetting the key needs no hint, got %d", len(effects))
}
}
func TestCheckConfigUnsetSideEffects_FederationRemote(t *testing.T) {
effects := checkConfigUnsetSideEffects("federation.remote")
if len(effects) != 1 {

View file

@ -11,7 +11,6 @@ import (
"testing"
"github.com/steveyegge/beads/internal/storage/embeddeddolt"
"github.com/steveyegge/beads/internal/types"
)
// The TestEmbeddedContributorCreate* tests exercise the full contributor mode flow in
@ -99,67 +98,6 @@ func TestEmbeddedContributorCreateMultiple(t *testing.T) {
})
}
// TestEmbeddedContributorRoutedWritesCommitInPlanning runs, through the bd
// binary in a contributor checkout, the commands that change an issue living in
// the planning repository: each writes the change there and advances the
// planning database's HEAD, as the TestEmbeddedRoutedSiblingWritesCommitTargetHead*
// tests pin for a prefix route. While the contributor auto-route opened its
// target read-only, the embedded store refused every one of these writes.
func TestEmbeddedContributorRoutedWritesCommitInPlanning(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt contributor tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, planningDir := initContributor(t, bd, "cw")
planningBeadsDir := filepath.Join(planningDir, ".beads")
issue := bdCreate(t, bd, dir, "Planning issue")
question := bdCreate(t, bd, dir, "Planning question")
dismissed := bdCreate(t, bd, dir, "Planning request")
for _, step := range []struct {
name string
args []string
}{
{"update --claim", []string{"update", issue.ID, "--claim"}},
{"unclaim", []string{"unclaim", issue.ID}},
{"comment", []string{"comment", issue.ID, "planning comment"}},
{"close", []string{"close", issue.ID, "--reason", "done"}},
{"human respond", []string{"human", "respond", question.ID, "--response", "answered"}},
{"human dismiss", []string{"human", "dismiss", dismissed.ID, "--reason", "not needed"}},
} {
before := embeddedCurrentCommit(t, planningBeadsDir, "cw")
bdCommand(t, bd, dir, step.args...)
assertEmbeddedHeadAdvanced(t, planningBeadsDir, "cw", before, step.name)
}
planningStore := openStore(t, planningBeadsDir, "cw")
for _, id := range []string{issue.ID, question.ID, dismissed.ID} {
got, err := planningStore.GetIssue(t.Context(), id)
if err != nil {
t.Fatalf("GetIssue(%s) in the planning store: %v", id, err)
}
if got.Status != types.StatusClosed {
t.Errorf("%s status in the planning store = %q, want %q", id, got.Status, types.StatusClosed)
}
}
comments, err := planningStore.GetIssueComments(t.Context(), issue.ID)
if err != nil {
t.Fatalf("GetIssueComments: %v", err)
}
found := false
for _, c := range comments {
if c.Text == "planning comment" {
found = true
}
}
if !found {
t.Errorf("the comment did not land in the planning store: %+v", comments)
}
assertIssueNotInStore(t, filepath.Join(dir, ".beads"), "cw", issue.ID)
}
// initContributor sets up a project with contributor mode enabled and returns
// the project dir and planning dir paths. The contributor wizard runs via
// subprocess with stdin piped to answer the interactive prompts.

View file

@ -373,11 +373,6 @@ var createCmd = &cobra.Command{
}
if dryRun && parentID == "" {
// The preview opens no target, but it refuses a local one in a
// format this build cannot open, as the create it previews would.
if err := checkRepoTargetFormat(repoPath); err != nil {
return handleWorkspaceGuardError(err)
}
return renderDryRun()
}
@ -407,9 +402,6 @@ var createCmd = &cobra.Command{
// flag value can be ambiguous.
allowCreate := !isAmbiguousRepoTarget(cmd.Flags().Changed("repo"), repoOverride)
if err := ensureBeadsDirForPath(rootCtx, targetBeadsDir, store, allowCreate); err != nil {
if isUnsupportedWorkspaceFormat(err) {
return handleWorkspaceGuardError(err)
}
return HandleError("failed to initialize target repo: %v", err)
}
@ -977,12 +969,8 @@ func init() {
}
// handleCreateTargetStoreError preserves the existing text path for ordinary
// store failures while rendering capability refusals as typed JSON when asked,
// and a target in a format this build cannot open as the workspace refusal.
// store failures while rendering capability refusals as typed JSON when asked.
func handleCreateTargetStoreError(err error, targetPath, fallbackFormat string) error {
if isUnsupportedWorkspaceFormat(err) {
return handleWorkspaceGuardError(err)
}
var capErr *ProxyCapabilityError
if !errors.As(err, &capErr) {
return HandleError(fallbackFormat, err)
@ -1032,12 +1020,6 @@ func openDryRunTargetStore(ctx context.Context, repoPath string) (storage.DoltSt
targetPath := routing.ExpandPath(repoPath)
beadsDir := filepath.Join(targetPath, ".beads")
// A target in a format this build cannot open is refused as that, even
// one marked only by a legacy config.json, which the check below would
// report as not initialized.
if err := checkDiscoveredWorkspaceFormat(beadsDir); err != nil {
return nil, err
}
metadataPath := filepath.Join(beadsDir, "metadata.json")
if _, err := os.Stat(metadataPath); err != nil {
if os.IsNotExist(err) {
@ -1053,17 +1035,6 @@ func openDryRunTargetStore(ctx context.Context, repoPath string) (storage.DoltSt
return store, nil
}
// checkRepoTargetFormat refuses a local create target in a format this build
// cannot open, reading its metadata without opening or migrating it. The
// command's own workspace (".") has passed admission already, and a remote
// target has no local metadata to read, so both pass.
func checkRepoTargetFormat(repoPath string) error {
if repoPath == "." || remotecache.IsRemoteURL(repoPath) {
return nil
}
return checkDiscoveredWorkspaceFormat(filepath.Join(routing.ExpandPath(repoPath), ".beads"))
}
// isAmbiguousRepoTarget reports whether an explicit --repo value is a
// bare/relative filesystem path (not absolute, not "~/"-prefixed). Such a
// value silently resolves against the current working directory (see
@ -1084,14 +1055,6 @@ func ensureBeadsDirForPath(ctx context.Context, targetPath string, sourceStore s
beadsDir := filepath.Join(targetPath, ".beads")
metadataPath := filepath.Join(beadsDir, "metadata.json")
// A target in a format this build cannot open is refused before anything
// below: one marked only by a legacy config.json or by the graph format
// marker file has no metadata.json, so it would otherwise be initialized
// here, with an Issue database and a metadata.json written beside it.
if err := checkDiscoveredWorkspaceFormat(beadsDir); err != nil {
return err
}
// Check if beads directory already exists with a Dolt database.
// metadata.json is the canonical marker for an initialized beads dir.
if _, err := os.Stat(metadataPath); err == nil {

View file

@ -390,14 +390,6 @@ func TestEmbeddedDepBTreeAndCycles(t *testing.T) {
if !strings.Contains(out, "flowchart") && !strings.Contains(out, "graph") {
t.Errorf("expected mermaid flowchart/graph syntax: %s", out)
}
// Mixed-case pins case-folding at the runDepTree dispatch site.
// TestDepTreeFormatMermaidCaseInsensitive calls isMermaidTreeFormat
// directly and would stay green if the call site went back to
// formatStr == "mermaid" (the PR #6646 bug).
mixed := bdDep(t, bd, dir, "tree", epic.ID, "--format", "Mermaid")
if !strings.Contains(mixed, "flowchart") && !strings.Contains(mixed, "graph") {
t.Errorf("expected mermaid flowchart/graph syntax for --format Mermaid: %s", mixed)
}
})
t.Run("tree_json_output", func(t *testing.T) {

View file

@ -1,86 +0,0 @@
//go:build cgo
package main
import (
"bytes"
"encoding/json"
"errors"
"os"
"os/exec"
"path/filepath"
"testing"
)
// TestEmbeddedDiscoveryPinsEnvFileReadonly is the store-backed member of the
// before-parity discovery pins (discovery_refusal_pins_test.go holds the
// store-less ones). It pins how an ordinary workspace applies a BD_READONLY
// supplied by its own .beads/.env: a write is refused with the read-only text
// and exit 1, also under --json, while reads still run; and a BD_READONLY the
// caller exports wins over the file.
func TestEmbeddedDiscoveryPinsEnvFileReadonly(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, beadsDir, _ := bdInit(t, bd, "--prefix", "pin")
if err := os.WriteFile(filepath.Join(beadsDir, ".env"), []byte("BD_READONLY=true\n"), 0o600); err != nil {
t.Fatalf("write .beads/.env: %v", err)
}
run := func(extraEnv []string, args ...string) (exit int, stdout, stderr string) {
t.Helper()
cmd := exec.Command(bd, args...)
cmd.Dir = dir
// The store-less pins' closed environment: no BD_*/BEADS_* the caller
// exports (BD_READONLY, BD_JSON_ENVELOPE, BD_OTEL_*, ...) reaches bd.
// HOME stays dir, where bd init ran.
cmd.Env = append(discoveryPinEnv(dir, filepath.Join(dir, "no-such-freeze-marker")),
"BEADS_DOLT_AUTO_START=0", "BEADS_NO_DAEMON=1")
cmd.Env = append(cmd.Env, extraEnv...)
var out, errOut bytes.Buffer
cmd.Stdout, cmd.Stderr = &out, &errOut
if err := cmd.Run(); err != nil {
var exitErr *exec.ExitError
if !errors.As(err, &exitErr) {
t.Fatalf("run bd %v: %v", args, err)
}
exit = exitErr.ExitCode()
}
return exit, out.String(), discoveryPinSandboxNotice.ReplaceAllLiteralString(errOut.String(), "")
}
exit, stdout, stderr := run(nil, "create", "refused by .env", "--json")
if exit != 1 || stdout != "" || stderr != "Error: operation 'create' is not allowed in read-only mode\n" {
t.Fatalf("create under .env BD_READONLY=true: exit=%d stdout=%q stderr=%q; want exit=1, no stdout, the read-only refusal", exit, stdout, stderr)
}
exit, stdout, stderr = run(nil, "list", "--json")
if exit != 0 || stdout != "[]\n" {
t.Fatalf("list under .env BD_READONLY=true: exit=%d stdout=%q stderr=%q; want exit=0 and an empty list", exit, stdout, stderr)
}
exit, stdout, stderr = run([]string{"BD_READONLY=false"}, "create", "allowed by the caller", "--json")
if exit != 0 {
t.Fatalf("create with exported BD_READONLY=false: exit=%d stdout=%q stderr=%q; want the caller's setting to win", exit, stdout, stderr)
}
var created struct {
Title string `json:"title"`
}
if err := json.Unmarshal([]byte(stdout), &created); err != nil || created.Title != "allowed by the caller" {
t.Fatalf("create with exported BD_READONLY=false printed %q (decode error %v)", stdout, err)
}
exit, stdout, stderr = run(nil, "list", "--json")
var listed []struct {
Title string `json:"title"`
}
if exit != 0 {
t.Fatalf("list after the allowed create: exit=%d stderr=%q", exit, stderr)
}
if err := json.Unmarshal([]byte(stdout), &listed); err != nil || len(listed) != 1 || listed[0].Title != "allowed by the caller" {
t.Fatalf("list after the allowed create = %q (decode error %v); want only the allowed issue, the refused create wrote nothing", stdout, err)
}
}

View file

@ -1,885 +0,0 @@
//go:build cgo
package main
// Before-parity pins for workspace discovery refusals.
//
// These tests hold the exact text and exit code an ordinary bd prints when
// workspace discovery cannot select a usable workspace: a missing or corrupt
// metadata.json, an explicit BEADS_DIR that names no workspace, selection
// supplied by .beads/.env, .beads/redirect files, --db / BEADS_DB / BD_DB
// selection, and the blocked backend environment variables. They pin what
// origin/main does today, not what it ideally should do. A change that
// reorders admission, discovery or checkBlockedEnvVars in the root
// PersistentPreRunE has to change an expectation here, so it shows up in
// review as a test diff rather than as an unexplained behavior change.
//
// Every case runs the real bd binary in a fresh fixture and stops before any
// store is opened, so these need no Dolt server or database. Fixture
// workspaces with a corrupt metadata.json double as sentinels: the refusal
// names the metadata.json it failed to parse, so the text shows which
// directory discovery selected without opening a database.
//
// The pinned no-database hints are an embedded-capable bd's. A CGO_ENABLED=0
// bd is server-only and adds "run 'bd doctor' to diagnose" to them, so this
// file builds only with cgo, and the bd it runs (built by
// buildBDForInitTests, or BEADS_TEST_BD_BINARY) must be a cgo build too.
import (
"bytes"
"errors"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"sort"
"strings"
"testing"
"github.com/steveyegge/beads/internal/testutil"
)
// pinNoDatabaseRefusal is what a store-requiring command prints when
// discovery finds no workspace with a database.
const pinNoDatabaseRefusal = "Error: no beads database found\n" +
"Hint: run 'bd where' to inspect the resolved workspace, or 'bd init' to create a new database\n" +
" or set BEADS_DIR to point to your .beads directory\n"
// pinNoWorkspaceWhereRefusal is bd where's text refusal when no workspace is
// selected.
const pinNoWorkspaceWhereRefusal = "Error: No active beads workspace found.\n" +
"Hint: check BEADS_DIR/worktree setup, or run 'bd init' to create a new database\n"
// pinNoWorkspaceWhereJSON is bd where --json's refusal. It goes to stdout.
const pinNoWorkspaceWhereJSON = `{
"error": "no_beads_directory",
"hint": "check BEADS_DIR/worktree setup, or run 'bd init' to create a new database",
"message": "No active beads workspace found.",
"schema_version": 1
}
`
// pinCorruptMetadata is the content of every corrupt metadata.json fixture.
const pinCorruptMetadata = "{\n"
// pinCorruptMetadataWarning is the warning printed while the selected
// workspace is bound, before the refusal itself.
func pinCorruptMetadataWarning(beadsDir string) string {
return "warning: load " + beadsDir + "/metadata.json: parsing config: unexpected end of JSON input; " +
"no storage database was opened or modified (storage mode unknown; data commands refuse to fall back to the embedded store)\n"
}
// pinCorruptMetadataRefusal is the full stderr of a command refused because
// the selected workspace's metadata.json does not parse.
func pinCorruptMetadataRefusal(beadsDir string) string {
return pinCorruptMetadataWarning(beadsDir) +
"Error: loading config: parsing config: unexpected end of JSON input\n"
}
// pinBlockedEnvRefusal is checkBlockedEnvVars' refusal for name.
func pinBlockedEnvRefusal(name string) string {
return "Error: " + name + " env var is not supported and has been removed to prevent data fragmentation.\n" +
"Unset " + name + "; storage selection comes from .beads/metadata.json. " +
"To choose a different supported backend, follow 'bd help init-safety'; do not edit metadata.json by hand\n"
}
// discoveryPinCase is one bd invocation and its exact expected result. The
// arguments and the expected strings write the fixture root as $ROOT.
type discoveryPinCase struct {
name string
// setup builds the fixture and returns the working directory and any
// environment the invocation adds to the hermetic base.
setup func(f *discoveryPinFixture) (cwd string, env []string)
args []string
exit int
stdout string
stderr string
// stderrPrefix compares only the start of stderr. Use it only where the
// rest of the output is not part of the pin.
stderrPrefix bool
}
func runDiscoveryPinCases(t *testing.T, cases []discoveryPinCase) {
t.Helper()
if runtime.GOOS == "windows" {
t.Skip("the pinned texts embed POSIX paths")
}
t.Parallel()
bd := buildBDForInitTests(t)
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
f := newDiscoveryPinFixture(t)
cwd, env := tc.setup(f)
args := make([]string, len(tc.args))
for i, arg := range tc.args {
args[i] = strings.ReplaceAll(arg, "$ROOT", f.root)
}
exit, stdout, stderr := f.run(bd, cwd, env, args...)
if exit != tc.exit {
t.Errorf("bd %s: exit = %d, want %d", strings.Join(tc.args, " "), exit, tc.exit)
}
if stdout != tc.stdout {
t.Errorf("bd %s: stdout differs\n got: %q\nwant: %q", strings.Join(tc.args, " "), stdout, tc.stdout)
}
gotStderr := stderr
if tc.stderrPrefix && len(gotStderr) > len(tc.stderr) {
gotStderr = gotStderr[:len(tc.stderr)]
}
if gotStderr != tc.stderr {
t.Errorf("bd %s: stderr differs\n got: %q\nwant: %q", strings.Join(tc.args, " "), stderr, tc.stderr)
}
})
}
}
type discoveryPinFixture struct {
t *testing.T
root string
forms []string // spellings of root to rewrite as $ROOT, longest first
}
func newDiscoveryPinFixture(t *testing.T) *discoveryPinFixture {
t.Helper()
root := t.TempDir()
forms := []string{root}
if resolved, err := filepath.EvalSymlinks(root); err == nil && resolved != root {
forms = append(forms, resolved)
}
sort.Slice(forms, func(i, j int) bool { return len(forms[i]) > len(forms[j]) })
f := &discoveryPinFixture{t: t, root: root, forms: forms}
f.mkdir("home")
return f
}
// path returns the absolute path of a root-relative slash path.
func (f *discoveryPinFixture) path(rel string) string {
return filepath.Join(f.root, filepath.FromSlash(rel))
}
func (f *discoveryPinFixture) mkdir(rel string) string {
f.t.Helper()
dir := f.path(rel)
if err := os.MkdirAll(dir, 0o700); err != nil {
f.t.Fatalf("mkdir %s: %v", dir, err)
}
return dir
}
func (f *discoveryPinFixture) write(rel, content string) {
f.t.Helper()
if err := os.WriteFile(f.path(rel), []byte(content), 0o600); err != nil {
f.t.Fatalf("write %s: %v", rel, err)
}
}
// project creates rel as a git repository with no .beads. The repository
// root is the discovery walk's boundary, so nothing above the fixture leaks
// into a case.
func (f *discoveryPinFixture) project(rel string) string {
f.t.Helper()
dir := f.mkdir(rel)
initGitRepoAt(f.t, dir)
return dir
}
// workspace creates project rel with a .beads directory holding files, each
// named relative to .beads.
func (f *discoveryPinFixture) workspace(rel string, files map[string]string) string {
f.t.Helper()
dir := f.project(rel)
f.mkdir(rel + "/.beads")
for name, content := range files {
f.write(rel+"/.beads/"+name, content)
}
return dir
}
// corruptWorkspace creates project rel whose metadata.json does not parse,
// plus any extra .beads files.
func (f *discoveryPinFixture) corruptWorkspace(rel string, extra map[string]string) string {
f.t.Helper()
files := map[string]string{"metadata.json": pinCorruptMetadata}
for name, content := range extra {
files[name] = content
}
return f.workspace(rel, files)
}
// yamlWorkspace creates project rel whose .beads holds only a config.yaml
// (no metadata.json and no database), plus any extra .beads files.
func (f *discoveryPinFixture) yamlWorkspace(rel string, extra map[string]string) string {
f.t.Helper()
files := map[string]string{"config.yaml": "# discovery pin fixture\n"}
for name, content := range extra {
files[name] = content
}
return f.workspace(rel, files)
}
// discoveryPinEnv is the caller environment without any BEADS_*/BD_*
// selector or setting and without git repository-location variables, with
// HOME and XDG_CONFIG_HOME under home, metrics and event flush off, and the
// migration freeze marker pointed at freezeMarker, a path that does not exist.
func discoveryPinEnv(home, freezeMarker string) []string {
var env []string
for _, kv := range testutil.WithoutGitRepoLocationEnv(os.Environ()) {
key, _, _ := strings.Cut(kv, "=")
if strings.HasPrefix(key, "BEADS_") || strings.HasPrefix(key, "BD_") ||
key == "HOME" || key == "XDG_CONFIG_HOME" {
continue
}
env = append(env, kv)
}
return append(env,
"HOME="+home,
"XDG_CONFIG_HOME="+filepath.Join(home, ".config"),
"BD_DISABLE_METRICS=1",
"BD_DISABLE_EVENT_FLUSH=1",
"BD_MIGRATION_FREEZE_FILE="+freezeMarker,
)
}
func (f *discoveryPinFixture) run(bd, cwd string, extraEnv []string, args ...string) (exit int, stdout, stderr string) {
f.t.Helper()
cmd := exec.Command(bd, args...)
cmd.Dir = cwd
cmd.Env = append(discoveryPinEnv(f.path("home"), f.path("no-such-freeze-marker")), extraEnv...)
var out, errOut bytes.Buffer
cmd.Stdout, cmd.Stderr = &out, &errOut
if err := cmd.Run(); err != nil {
var exitErr *exec.ExitError
if !errors.As(err, &exitErr) {
f.t.Fatalf("run bd %s: %v", strings.Join(args, " "), err)
}
exit = exitErr.ExitCode()
}
return exit, f.normalize(out.String(), false), f.normalize(errOut.String(), true)
}
var discoveryPinVersionLine = regexp.MustCompile(`(?m)^bd version .*$`)
// discoveryPinDuplicateBinaries matches the warning bd version appends when
// the caller's PATH holds more than one distinct bd binary.
var discoveryPinDuplicateBinaries = regexp.MustCompile(
`\nWarning: multiple 'bd' binaries found in PATH:\n(?: [^\n]*\n)*` +
`The first one is being used\. Remove duplicates to avoid confusion\.\n`)
// discoveryPinSandboxNotice matches the notice bd prints when it auto-detects
// a sandbox, which it does when it is not allowed to signal its own process.
var discoveryPinSandboxNotice = regexp.MustCompile(`(?m)^.*Sandbox detected, using direct mode\n`)
// normalize rewrites the fixture root as $ROOT and the build's version line
// as "bd version $VERSION". For stderr it also drops the notices that depend
// on the caller's environment rather than on the fixture (sandbox
// auto-detection, and bd version's duplicate binaries in PATH) and collapses
// consecutive repeats of a "Warning: redirect" line: discovery re-resolves
// the same redirect several times per invocation and how many times it warns
// is not part of the pin. Any other repeated line, such as a doubled
// "Error:", is kept.
func (f *discoveryPinFixture) normalize(s string, stderr bool) string {
for _, form := range f.forms {
s = strings.ReplaceAll(s, form, "$ROOT")
}
s = discoveryPinVersionLine.ReplaceAllLiteralString(s, "bd version $VERSION")
if !stderr {
return s
}
s = discoveryPinDuplicateBinaries.ReplaceAllLiteralString(s, "")
s = discoveryPinSandboxNotice.ReplaceAllLiteralString(s, "")
var b strings.Builder
prev := ""
for _, line := range strings.SplitAfter(s, "\n") {
if line == prev && strings.HasPrefix(line, "Warning: redirect ") {
continue
}
b.WriteString(line)
prev = line
}
return b.String()
}
// TestDiscoveryRefusalPinsMissingMetadata pins discovery when no workspace,
// a workspace without metadata.json and without a database, or a .beads that
// is a regular file is found.
func TestDiscoveryRefusalPinsMissingMetadata(t *testing.T) {
noBeads := func(f *discoveryPinFixture) (string, []string) { return f.project("p"), nil }
regularFileBeads := func(f *discoveryPinFixture) (string, []string) {
cwd := f.project("p")
f.write("p/.beads", "not a workspace\n")
return cwd, nil
}
runDiscoveryPinCases(t, []discoveryPinCase{
{
name: "no-beads-dir/list",
setup: noBeads,
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
// --json does not turn the refusal into a JSON document.
name: "no-beads-dir/list-json",
setup: noBeads,
args: []string{"list", "--json"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "no-beads-dir/where",
setup: noBeads,
args: []string{"where"},
exit: 1,
stderr: pinNoWorkspaceWhereRefusal,
},
{
name: "no-beads-dir/where-json",
setup: noBeads,
args: []string{"where", "--json"},
exit: 1,
stdout: pinNoWorkspaceWhereJSON,
},
{
name: "empty-beads-dir/list",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.workspace("p", nil), nil
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "config-yaml-only/list",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.yamlWorkspace("p", nil), nil
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
// The same directory is a workspace to bd where.
name: "config-yaml-only/where",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.yamlWorkspace("p", nil), nil
},
args: []string{"where"},
stdout: "$ROOT/p/.beads\n",
},
{
// The working-directory walk selects a .beads that is a regular
// file, then fails to read its metadata.json (the BEADS_DIR form
// is in TestDiscoveryRefusalPinsExplicitBeadsDir).
name: "beads-is-regular-file/list",
setup: regularFileBeads,
args: []string{"list"},
exit: 1,
stderr: "Error: loading config: reading config: open $ROOT/p/.beads/metadata.json: not a directory\n",
},
{
name: "beads-is-regular-file/where",
setup: regularFileBeads,
args: []string{"where"},
exit: 1,
stderr: "Error: loading config: reading config: open $ROOT/p/.beads/metadata.json: not a directory\n",
},
})
}
// TestDiscoveryRefusalPinsCorruptMetadata pins the refusal for a discovered
// workspace whose metadata.json does not parse.
func TestDiscoveryRefusalPinsCorruptMetadata(t *testing.T) {
corrupt := func(f *discoveryPinFixture) (string, []string) { return f.corruptWorkspace("p", nil), nil }
runDiscoveryPinCases(t, []discoveryPinCase{
{
name: "list",
setup: corrupt,
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "list-json",
setup: corrupt,
args: []string{"list", "--json"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "create",
setup: corrupt,
args: []string{"create", "must not be written", "--json"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
// bd where never opens a store, but it still refuses.
name: "where",
setup: corrupt,
args: []string{"where"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "where-json",
setup: corrupt,
args: []string{"where", "--json"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
// bd version warns and succeeds.
name: "version",
setup: corrupt,
args: []string{"version"},
stdout: "bd version $VERSION\n",
stderr: pinCorruptMetadataWarning("$ROOT/p/.beads"),
},
})
}
// TestDiscoveryRefusalPinsExplicitBeadsDir pins an exported BEADS_DIR that
// names no workspace. Each case runs from a corrupt workspace, so falling
// back to discovery from the working directory would print that workspace's
// refusal instead.
func TestDiscoveryRefusalPinsExplicitBeadsDir(t *testing.T) {
from := func(beadsDir func(f *discoveryPinFixture) string) func(f *discoveryPinFixture) (string, []string) {
return func(f *discoveryPinFixture) (string, []string) {
cwd := f.corruptWorkspace("cwd", nil)
return cwd, []string{"BEADS_DIR=" + beadsDir(f)}
}
}
missing := from(func(f *discoveryPinFixture) string { return f.path("missing/.beads") })
runDiscoveryPinCases(t, []discoveryPinCase{
{
name: "missing-dir/list",
setup: missing,
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "missing-dir/where",
setup: missing,
args: []string{"where"},
exit: 1,
stderr: pinNoWorkspaceWhereRefusal,
},
{
name: "missing-dir/where-json",
setup: missing,
args: []string{"where", "--json"},
exit: 1,
stdout: pinNoWorkspaceWhereJSON,
},
{
name: "empty-dir/list",
setup: from(func(f *discoveryPinFixture) string { return f.mkdir("empty") }),
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "regular-file/list",
setup: from(func(f *discoveryPinFixture) string {
f.write("file", "not a workspace\n")
return f.path("file")
}),
args: []string{"list"},
exit: 1,
stderr: "Error: loading config: reading config: open $ROOT/file/metadata.json: not a directory\n",
},
{
name: "corrupt-workspace/list",
setup: from(func(f *discoveryPinFixture) string {
f.corruptWorkspace("other", nil)
return f.path("other/.beads")
}),
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/other/.beads"),
},
})
}
// TestDiscoveryRefusalPinsBeadsEnvFile pins settings supplied by the
// discovered workspace's .beads/.env.
func TestDiscoveryRefusalPinsBeadsEnvFile(t *testing.T) {
runDiscoveryPinCases(t, []discoveryPinCase{
{
// A .env BEADS_DIR routes discovery to its target.
name: "beads-dir-routes-to-target",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
return f.yamlWorkspace("p", map[string]string{".env": "BEADS_DIR=" + f.path("target/.beads") + "\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// The routing workspace's own corrupt metadata.json causes no refusal.
name: "beads-dir-route-skips-local-metadata",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", map[string]string{".env": "BEADS_DIR=" + f.path("missing/.beads") + "\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
// An exported BEADS_DIR wins; the .env is never read.
name: "exported-beads-dir-wins",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
cwd := f.yamlWorkspace("p", map[string]string{".env": "BEADS_DIR=" + f.path("target/.beads") + "\n"})
return cwd, []string{"BEADS_DIR=" + f.path("missing/.beads")}
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
// A .env BEADS_DB does not route a data command away from the
// workspace that holds the .env (the shadowing
// TestDiscoveryRefusalPinsDBSelection records for an exported
// BEADS_DB) ...
name: "beads-db-list",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
return f.yamlWorkspace("p", map[string]string{".env": "BEADS_DB=" + f.path("target/.beads/dolt") + "\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
// ... but it does route bd where.
name: "beads-db-where",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
return f.yamlWorkspace("p", map[string]string{".env": "BEADS_DB=" + f.path("target/.beads/dolt") + "\n"}), nil
},
args: []string{"where"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// Settings in the selected workspace's .env apply (BD_JSON here).
name: "setting-applies-in-selected-workspace",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.yamlWorkspace("p", map[string]string{".env": "BD_JSON=true\n"}), nil
},
args: []string{"where"},
stdout: "{\n \"path\": \"$ROOT/p/.beads\",\n \"schema_version\": 1\n}\n",
},
{
// A .env that routes elsewhere contributes only its selector:
// its other settings are not imported, so the refusal is text.
name: "setting-not-imported-from-routing-source",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.yamlWorkspace("p", map[string]string{".env": "BD_JSON=true\nBEADS_DIR=" + f.path("missing/.beads") + "\n"}), nil
},
args: []string{"where"},
exit: 1,
stderr: pinNoWorkspaceWhereRefusal,
},
{
// checkBlockedEnvVars sees only the exported environment, and runs
// before any .env is loaded: a .env BD_BACKEND is not refused, here
// or anywhere before discovery's own no-database refusal.
name: "blocked-backend-not-checked",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.yamlWorkspace("p", map[string]string{".env": "BD_BACKEND=sqlite\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
})
}
// TestDiscoveryRefusalPinsRedirect pins .beads/redirect handling: the
// warnings for unusable targets and which directory is selected afterwards.
func TestDiscoveryRefusalPinsRedirect(t *testing.T) {
runDiscoveryPinCases(t, []discoveryPinCase{
{
// A missing target is ignored and discovery keeps the source.
name: "missing-target",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", map[string]string{"redirect": f.path("missing/.beads") + "\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: "Warning: redirect target does not exist or is not a directory: $ROOT/missing/.beads\n" +
pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
// A target without project files is ignored the same way.
name: "target-without-workspace",
setup: func(f *discoveryPinFixture) (string, []string) {
f.mkdir("bare/.beads")
return f.corruptWorkspace("p", map[string]string{"redirect": "../bare/.beads\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: "Warning: ignoring redirect from $ROOT/p/.beads to $ROOT/bare/.beads because the target has no database or metadata.json; fix or delete the redirect file\n" +
pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "corrupt-target",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
return f.workspace("p", map[string]string{"redirect": "../target/.beads\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// Only one level is followed.
name: "chain",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("final", nil)
f.corruptWorkspace("middle", map[string]string{"redirect": "../final/.beads\n"})
return f.workspace("p", map[string]string{"redirect": "../middle/.beads\n"}), nil
},
args: []string{"list"},
exit: 1,
stderr: "Warning: redirect chains not allowed, ignoring redirect in $ROOT/middle/.beads\n" +
pinCorruptMetadataRefusal("$ROOT/middle/.beads"),
},
{
// An explicit BEADS_DIR is followed through its redirect.
name: "explicit-beads-dir",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
f.workspace("source", map[string]string{"redirect": "../target/.beads\n"})
return f.project("p"), []string{"BEADS_DIR=" + f.path("source/.beads")}
},
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
name: "where-reports-source",
setup: func(f *discoveryPinFixture) (string, []string) {
f.yamlWorkspace("target", nil)
return f.workspace("p", map[string]string{"redirect": "../target/.beads\n"}), nil
},
args: []string{"where"},
stdout: "$ROOT/target/.beads\n (via redirect from $ROOT/p/.beads)\n",
},
})
}
// TestDiscoveryRefusalPinsDBSelection pins database selection by --db and by
// the BEADS_DB and BD_DB environment variables.
//
// Two of these record inconsistencies as they stand rather than endorse
// them: a data command ignores BD_DB, and lets a discoverable workspace in
// the working directory shadow BEADS_DB, while bd where honors both.
func TestDiscoveryRefusalPinsDBSelection(t *testing.T) {
target := func(f *discoveryPinFixture) string {
f.corruptWorkspace("target", nil)
return f.path("target/.beads/dolt")
}
runDiscoveryPinCases(t, []discoveryPinCase{
{
// A --db path selects the workspace that owns it.
name: "db-path",
setup: func(f *discoveryPinFixture) (string, []string) {
target(f)
return f.project("p"), nil
},
args: []string{"--db", "$ROOT/target/.beads/dolt", "list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
name: "db-path-beats-beads-dir",
setup: func(f *discoveryPinFixture) (string, []string) {
target(f)
f.corruptWorkspace("other", nil)
return f.project("p"), []string{"BEADS_DIR=" + f.path("other/.beads")}
},
args: []string{"--db", "$ROOT/target/.beads/dolt", "list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
name: "db-path-beats-working-directory",
setup: func(f *discoveryPinFixture) (string, []string) {
target(f)
return f.corruptWorkspace("p", nil), nil
},
args: []string{"--db", "$ROOT/target/.beads/dolt", "list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// A --db value that is a database name rather than an existing
// path leaves discovery to the working directory.
name: "db-name-without-workspace",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), nil
},
args: []string{"--db", "pindb", "list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "db-name-in-workspace",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", nil), nil
},
args: []string{"--db", "pindb", "list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "beads-db-env",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BEADS_DB=" + target(f)}
},
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// Inconsistency: the working directory's workspace shadows BEADS_DB.
name: "beads-db-env-shadowed-by-working-directory",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", nil), []string{"BEADS_DB=" + target(f)}
},
args: []string{"list"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/p/.beads"),
},
{
name: "beads-db-env-where",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", nil), []string{"BEADS_DB=" + target(f)}
},
args: []string{"where"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
{
// Inconsistency: a data command ignores BD_DB.
name: "bd-db-env",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_DB=" + target(f)}
},
args: []string{"list"},
exit: 1,
stderr: pinNoDatabaseRefusal,
},
{
name: "bd-db-env-where",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_DB=" + target(f)}
},
args: []string{"where"},
exit: 1,
stderr: pinCorruptMetadataRefusal("$ROOT/target/.beads"),
},
})
}
// TestDiscoveryRefusalPinsBlockedEnvVarsRunFirst pins that the blocked
// backend variables are refused before any discovery, for every command.
func TestDiscoveryRefusalPinsBlockedEnvVarsRunFirst(t *testing.T) {
runDiscoveryPinCases(t, []discoveryPinCase{
{
name: "no-workspace",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_BACKEND=sqlite"}
},
args: []string{"list"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
name: "corrupt-metadata",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", nil), []string{"BD_BACKEND=sqlite"}
},
args: []string{"list"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
name: "explicit-beads-dir",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_BACKEND=sqlite", "BEADS_DIR=" + f.path("missing/.beads")}
},
args: []string{"list"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
// A BEADS_DIR that cannot even be read as a directory is still
// reached only after the blocked variable is refused.
name: "unreadable-beads-dir",
setup: func(f *discoveryPinFixture) (string, []string) {
f.write("file", "not a workspace\n")
return f.project("p"), []string{"BD_BACKEND=sqlite", "BEADS_DIR=" + f.path("file")}
},
args: []string{"list"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
name: "db-path",
setup: func(f *discoveryPinFixture) (string, []string) {
f.corruptWorkspace("target", nil)
return f.project("p"), []string{"BD_BACKEND=sqlite"}
},
args: []string{"--db", "$ROOT/target/.beads/dolt", "list"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
// --json does not turn the refusal into a JSON document.
name: "database-backend-json",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.corruptWorkspace("p", nil), []string{"BD_DATABASE_BACKEND=dolt"}
},
args: []string{"list", "--json"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_DATABASE_BACKEND"),
},
{
name: "where-json",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_BACKEND=sqlite"}
},
args: []string{"where", "--json"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
name: "version-command",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_BACKEND=sqlite"}
},
args: []string{"version"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
},
{
// The root command then prints cobra's error and usage; only the
// refusal itself is pinned.
name: "version-flag",
setup: func(f *discoveryPinFixture) (string, []string) {
return f.project("p"), []string{"BD_BACKEND=sqlite"}
},
args: []string{"--version"},
exit: 1,
stderr: pinBlockedEnvRefusal("BD_BACKEND"),
stderrPrefix: true,
},
})
}

View file

@ -220,7 +220,7 @@ Examples:
if err := validateDoctorWorkspaceBackend(absPath); isLegacyUpgradeRefusal(err) {
return printLegacyUpgradeDiagnostic(err)
} else if err != nil {
return handleWorkspaceGuardError(err)
return HandleError("%v", err)
}
if doctorFix && isOrchestratorRoot(absPath) {

View file

@ -57,14 +57,6 @@ func TestMain(m *testing.M) {
}
func testMainInner(m *testing.M) int {
// A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook
// would route the fixture `git init`/`git config` writes in this suite
// into that repository: the host checkout in the r880 clobber (wy-qlvlmf).
if err := testutil.UnsetGitRepoLocationEnv(); err != nil {
fmt.Fprintf(os.Stderr, "FATAL: %v\n", err)
return 1
}
os.Setenv("BEADS_TEST_MODE", "1")
// AD-01 (be-c5p): doctor e2e tests connect to a per-package test server.
// The dolt.New database-name firewall requires this opt-in to allow

View file

@ -43,7 +43,6 @@ go_library(
"//internal/storage/issueops",
"//internal/types",
"//internal/utils",
"//internal/versionedhistory",
"@com_github_burntsushi_toml//:toml",
"@com_github_go_sql_driver_mysql//:mysql",
"@in_gopkg_yaml_v3//:yaml_v3",
@ -82,11 +81,7 @@ go_test(
"testmain_cgo_test.go",
"testmain_nocgo_test.go",
"validation_test.go",
"versioned_history_activation_test.go",
],
# versioned_history_activation_test.go parses store.go from its working
# directory, and a Bazel test only sees its declared runfiles.
data = ["store.go"],
embed = [":fix"],
deps = [
"//internal/configfile",

View file

@ -30,13 +30,8 @@ func initGitTemplate() {
}
gitTemplateDir = dir
// The template is built once, inside whichever test asks first. Its
// writes must land in dir even if that test set GIT_DIR/GIT_WORK_TREE,
// or they hit that repository (the r880 clobber class, wy-qlvlmf).
env := testutil.WithoutGitRepoLocationEnv(os.Environ())
cmd := gitCommand("init", "--initial-branch=main")
cmd.Dir = dir
cmd.Env = env
if err := cmd.Run(); err != nil {
gitTemplateErr = fmt.Errorf("git init failed: %w", err)
return
@ -48,7 +43,6 @@ func initGitTemplate() {
} {
cmd = gitCommand(args...)
cmd.Dir = dir
cmd.Env = env
if err := cmd.Run(); err != nil {
gitTemplateErr = fmt.Errorf("git %v failed: %w", args, err)
return

View file

@ -12,7 +12,6 @@ import (
mysql "github.com/go-sql-driver/mysql"
"github.com/steveyegge/beads/internal/configfile"
"github.com/steveyegge/beads/internal/testutil"
)
// TestFixMissingMetadata_NotBeadsWorkspace verifies that FixMissingMetadata
@ -200,21 +199,8 @@ func TestFixMissingMetadataJSON_NotBeadsWorkspace(t *testing.T) {
}
// setupGitRepoInDir initializes a git repo in the given directory with a remote.
//
// Every step is fatal on failure, the dir must exist, and the child env is
// scrubbed of the git vars that name a repository (GIT_DIR, GIT_WORK_TREE,
// ...). An empty dir, a swallowed config failure, or a leaked GIT_DIR each make
// these writes land in whatever repository git resolves from the process
// environment — the host checkout's own .git/config in the r880 clobber
// (wy-qlvlmf), where this helper's remote.origin.url overwrote the real origin.
func setupGitRepoInDir(t *testing.T, dir string) {
t.Helper()
if dir == "" {
t.Fatal("setupGitRepoInDir: empty dir would run git against the host checkout")
}
if info, err := os.Stat(dir); err != nil || !info.IsDir() {
t.Fatalf("setupGitRepoInDir: %q is not an existing directory (err=%v)", dir, err)
}
cmds := [][]string{
{"git", "init"},
{"git", "config", "user.email", "test@test.com"},
@ -225,9 +211,11 @@ func setupGitRepoInDir(t *testing.T, dir string) {
for _, args := range cmds {
cmd := exec.Command(args[0], args[1:]...)
cmd.Dir = dir
cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ())
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("%v failed: %v\n%s", args, err, out)
if err := cmd.Run(); err != nil {
// git init must succeed; config failures are non-fatal
if args[1] == "init" {
t.Fatalf("git init failed: %v", err)
}
}
}
}

View file

@ -5,11 +5,10 @@ import (
"github.com/steveyegge/beads/internal/eventsjournal"
"github.com/steveyegge/beads/internal/storage/dolt"
"github.com/steveyegge/beads/internal/versionedhistory"
)
// openBeadMutatingStore opens a repair handler's store WITH the workspace's
// events-journal and versioned-history activation applied.
// events-journal activation applied.
//
// Most of bd doctor inspects and repairs workspace state — schema cursors,
// metadata, remotes, fingerprints, git — and none of that belongs in a journal
@ -18,10 +17,7 @@ import (
// fresh-clone import paths CREATE them. Those are ordinary bead mutations, and
// a consumer whose mirror silently diverges because someone ran
// `bd doctor --fix` is exactly the failure the journal exists to prevent — the
// more so because a repair is unattended and nobody is watching the diff. The
// same repairs are also ordinary issue mutations for version history, and an
// issue_versions trail with a silent gap where `bd doctor --fix` ran is the same
// failure one table over.
// more so because a repair is unattended and nobody is watching the diff.
//
// The read-only and workspace-state handlers deliberately keep opening the
// store directly; they carry their exemption in the construction guard, with a
@ -31,7 +27,7 @@ import (
// is what a repair path legitimately does.
func openBeadMutatingStore(ctx context.Context, beadsDir string) (*dolt.DoltStore, error) {
store, err := dolt.NewFromConfig(ctx, beadsDir)
return activated(ctx, beadsDir, store, err)
return activated(beadsDir, store, err)
}
// openBeadMutatingStoreCreating is openBeadMutatingStore for the fresh-clone
@ -40,23 +36,15 @@ func openBeadMutatingStore(ctx context.Context, beadsDir string) (*dolt.DoltStor
// guard rather than failing on an absent database.
func openBeadMutatingStoreCreating(ctx context.Context, beadsDir string) (*dolt.DoltStore, error) {
store, err := dolt.NewFromConfigWithOptions(ctx, beadsDir, &dolt.Config{CreateIfMissing: true})
return activated(ctx, beadsDir, store, err)
return activated(beadsDir, store, err)
}
// activated applies the workspace's journal setting and the store's own
// versioned-history setting, and closes the store if the journal cannot be
// honored. A failed open passes straight through, so the typed-nil store never
// reaches the activation.
//
// Versioned history cannot fail an open (a plumbing that cannot version simply
// records nothing), so it needs no error handling of its own; it runs after the
// journal so a store the journal refused is never activated. It is the shared
// internal/versionedhistory rule, not a copy: package main cannot be imported
// from here.
func activated(ctx context.Context, beadsDir string, store *dolt.DoltStore, err error) (*dolt.DoltStore, error) {
// activated applies the workspace's journal setting and closes the store if it
// cannot be honored. A failed open passes straight through, so the typed-nil
// store never reaches the activation.
func activated(beadsDir string, store *dolt.DoltStore, err error) (*dolt.DoltStore, error) {
if _, err = eventsjournal.ActivateStore(beadsDir, store, err); err != nil {
return nil, err
}
_, _ = versionedhistory.ActivateStore(ctx, store, nil)
return store, nil
}

View file

@ -21,14 +21,6 @@ func TestMain(m *testing.M) {
// exits — os.Exit skips deferred calls, so TestMain itself must never defer
// anything (be-5kkk6).
func testMainInner(m *testing.M) int {
// A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook
// would route the fixture `git init`/`git config` writes in this suite
// into that repository: the host checkout in the r880 clobber (wy-qlvlmf).
if err := testutil.UnsetGitRepoLocationEnv(); err != nil {
fmt.Fprintf(os.Stderr, "FATAL: %v\n", err)
return 1
}
os.Setenv("BEADS_TEST_MODE", "1")
// AD-01 (be-c5p): allow doctor/fix tests through the dolt.New
// database-name firewall when they connect to the spawned test server.

View file

@ -19,14 +19,6 @@ func TestMain(m *testing.M) {
}
func testMainInner(m *testing.M) int {
// A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook
// would route the fixture `git init`/`git config` writes in this suite
// into that repository: the host checkout in the r880 clobber (wy-qlvlmf).
if err := testutil.UnsetGitRepoLocationEnv(); err != nil {
fmt.Fprintf(os.Stderr, "FATAL: %v\n", err)
return 1
}
// Clear out the roots of earlier runs of this suite whose process is
// gone, before claiming one of our own. A `go test -timeout` panic skips
// every defer here AND the post-run sweep, so the servers such a run

View file

@ -1,87 +0,0 @@
package fix
import (
"go/ast"
"go/parser"
"go/token"
"strconv"
"strings"
"testing"
)
const (
versionedHistoryPkg = "github.com/steveyegge/beads/internal/versionedhistory"
// package main cannot be imported at all; the guard below is that the
// activation this package applies lives in a package it CAN import, so the
// repair handlers apply the identical rule as the command surface rather than
// a copy of it.
beadMutatingStoreFile = "store.go"
)
// TestVersionedHistoryDoctorRepairOpenerUsesTheSharedActivation holds the one
// construction site the cmd/bd construction guard cannot see. bd doctor is exempted
// from that guard as a package (its CHECKS are read-only), so the repair opener --
// which opens the store the bead-mutating repairs (stale-closed cleanup, pollution
// cleanup, the fresh-clone imports) write through -- is held to the property here.
//
// A repair that deletes or creates issues is an ordinary mutation for version
// history: an issue_versions trail with a silent gap where `bd doctor --fix` ran is
// the same failure the routed-write bug produced, one command over, and the more
// dangerous for being unattended.
//
// The check is structural for the same reason the cmd/bd guard is: activation
// failing is invisible from inside the process. It requires the activation that
// `activated` applies to come from internal/versionedhistory -- the ONE
// implementation of the rule, which this package can import and package main cannot
// be.
func TestVersionedHistoryDoctorRepairOpenerUsesTheSharedActivation(t *testing.T) {
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, beadMutatingStoreFile, nil, 0)
if err != nil {
t.Fatalf("parse %s: %v", beadMutatingStoreFile, err)
}
imports := map[string]string{}
for _, spec := range file.Imports {
path, err := strconv.Unquote(spec.Path.Value)
if err != nil {
t.Fatalf("unquote import %s: %v", spec.Path.Value, err)
}
name := path[strings.LastIndex(path, "/")+1:]
if spec.Name != nil {
name = spec.Name.Name
}
imports[name] = path
}
var activated *ast.FuncDecl
for _, decl := range file.Decls {
if fn, ok := decl.(*ast.FuncDecl); ok && fn.Name.Name == "activated" {
activated = fn
}
}
if activated == nil {
t.Fatalf("%s has no `activated` function: the repair opener's activation moved and this guard no longer looks at it", beadMutatingStoreFile)
}
called := false
ast.Inspect(activated, func(n ast.Node) bool {
call, ok := n.(*ast.CallExpr)
if !ok {
return true
}
sel, ok := call.Fun.(*ast.SelectorExpr)
if !ok {
return true
}
if ident, ok := sel.X.(*ast.Ident); ok && imports[ident.Name] == versionedHistoryPkg && sel.Sel.Name == "ActivateStore" {
called = true
}
return true
})
if !called {
t.Errorf("`activated` in %s never calls versionedhistory.ActivateStore: every repair that mutates issues through it "+
"mints NO issue_versions row while `bd doctor --fix` reports success. Apply the shared activation there; "+
"it is the same rule as the command surface and package main cannot be imported to reuse it.", beadMutatingStoreFile)
}
}

View file

@ -30,13 +30,8 @@ func initGitTemplate() {
}
gitTemplateDir = dir
// The template is built once, inside whichever test asks first. Its
// writes must land in dir even if that test set GIT_DIR/GIT_WORK_TREE,
// or they hit that repository (the r880 clobber class, wy-qlvlmf).
env := testutil.WithoutGitRepoLocationEnv(os.Environ())
cmd := gitCommand("init", "--initial-branch=main")
cmd.Dir = dir
cmd.Env = env
if err := cmd.Run(); err != nil {
gitTemplateErr = fmt.Errorf("git init failed: %w", err)
return
@ -48,7 +43,6 @@ func initGitTemplate() {
} {
cmd = gitCommand(args...)
cmd.Dir = dir
cmd.Env = env
if err := cmd.Run(); err != nil {
gitTemplateErr = fmt.Errorf("git %v failed: %w", args, err)
return

View file

@ -5,8 +5,6 @@ import (
"path/filepath"
"strings"
"testing"
"github.com/steveyegge/beads/internal/testutil"
)
// setupGitRepo creates a temporary git repository for testing
@ -53,15 +51,6 @@ func TestCheckGitHooks(t *testing.T) {
// setupGitRepoInDir initializes a git repo in the given directory with .beads
func setupGitRepoInDir(t *testing.T, dir string) {
t.Helper()
if dir == "" {
// cmd.Dir = "" inherits the test process cwd — this checkout's own
// package dir — so the config write below would hit the host .git
// (the r880 clobber class, wy-qlvlmf).
t.Fatal("setupGitRepoInDir: empty dir would run git against the host checkout")
}
if info, err := os.Stat(dir); err != nil || !info.IsDir() {
t.Fatalf("setupGitRepoInDir: %q is not an existing directory (err=%v)", dir, err)
}
// Create .beads directory
beadsDir := filepath.Join(dir, ".beads")
@ -79,14 +68,11 @@ func setupGitRepoInDir(t *testing.T, dir string) {
}
// Force repo-local hooks path for test isolation. This prevents global
// core.hooksPath from affecting hook detection behavior in tests. The env
// scrub keeps a leaked GIT_DIR/GIT_WORK_TREE from routing the write at
// some other repository.
// core.hooksPath from affecting hook detection behavior in tests.
cmd := gitCommand("config", "core.hooksPath", ".git/hooks")
cmd.Dir = dir
cmd.Env = testutil.WithoutGitRepoLocationEnv(os.Environ())
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("failed to set core.hooksPath for test repo: %v\n%s", err, out)
if err := cmd.Run(); err != nil {
t.Fatalf("failed to set core.hooksPath for test repo: %v", err)
}
}

View file

@ -19,14 +19,6 @@ func TestMain(m *testing.M) {
}
func testMainInner(m *testing.M) int {
// A GIT_DIR/GIT_WORK_TREE leaked in from the invoking shell or a git hook
// would route the fixture `git init`/`git config` writes in this suite
// into that repository: the host checkout in the r880 clobber (wy-qlvlmf).
if err := testutil.UnsetGitRepoLocationEnv(); err != nil {
fmt.Fprintf(os.Stderr, "FATAL: %v\n", err)
return 1
}
// Clear out the roots of earlier runs of this suite whose process is
// gone, before claiming one of our own. A `go test -timeout` panic skips
// every defer here AND the post-run sweep, so the servers such a run

View file

@ -43,10 +43,10 @@ func runBDSplit(t *testing.T, bd, dir string, args ...string) (stdout, stderr st
return stdoutBuf.String(), stderrBuf.String(), err
}
// TestEmbeddedDoctorSupportedChecks verifies that --check=artifacts,
// TestDoctorEmbeddedSupportedChecks verifies that --check=artifacts,
// --check=conventions, and --check=pollution run in embedded mode rather
// than hitting the "not yet supported" stub (GH#3597).
func TestEmbeddedDoctorSupportedChecks(t *testing.T) {
func TestDoctorEmbeddedSupportedChecks(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -83,11 +83,11 @@ func TestEmbeddedDoctorSupportedChecks(t *testing.T) {
}
}
// TestEmbeddedDoctorUnsupportedJSON verifies that variants which still require
// TestDoctorEmbeddedUnsupportedJSON verifies that variants which still require
// server mode (bare doctor, --check=validate) emit a structured JSON payload
// when --json or --agent --json is set, rather than the prose stub. Tooling
// can detect "unsupported" without text-matching (GH#3597).
func TestEmbeddedDoctorUnsupportedJSON(t *testing.T) {
func TestDoctorEmbeddedUnsupportedJSON(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -150,10 +150,10 @@ func TestEmbeddedDoctorUnsupportedJSON(t *testing.T) {
}
}
// TestEmbeddedDoctorUnsupportedProse verifies that bare bd doctor (without
// TestDoctorEmbeddedUnsupportedProse verifies that bare bd doctor (without
// --json) still emits the human-readable prose stub for terminal users,
// pointing at the supported --check=* variants (GH#3597).
func TestEmbeddedDoctorUnsupportedProse(t *testing.T) {
func TestDoctorEmbeddedUnsupportedProse(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -9,28 +9,16 @@
// beside the rest of the freeze suite; both halves share the helpers below and
// the hermetic subprocess harness declared there.
//
// The same gate for `bd backup init`, `backup remove`, `backup sync` and
// `bd import` sits further down, between the doctor tests it mirrors.
//
// This file MUST NOT carry a cgo build tag: it drives a bd binary built with
// the gms_pure_go tag via subprocess, and asserts on files and output (and, for
// the server rows of the backup/import tests, on the Dolt test server's tables).
// the gms_pure_go tag via subprocess, and asserts only on files and output.
package main
import (
"context"
"database/sql"
"encoding/json"
"fmt"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"testing"
"github.com/steveyegge/beads/internal/storage/doltutil"
)
// doctorMutationSurface is one class of doctor invocation that mutates the
@ -134,306 +122,6 @@ func TestDoctorMutationBlockedInReadonlyMode(t *testing.T) {
}
}
// The backup and import commands: the same gate, a different failure.
//
// `bd backup init`, `backup remove`, `backup sync` and `bd import` never called
// CheckReadonly, so strict --readonly only held as far as the store underneath
// happened to refuse. An embedded store is opened read-only, so those commands
// failed, but with the storage layer's text rather than the standard refusal,
// and `backup sync` took the backup lock first and left .beads/backup.lock
// behind. A server-mode store has no such floor: the same commands ran to
// completion and rewrote or emptied the backup registry, wrote the backup
// destination, or imported issues. So every row runs in both flavours, and the
// checks go past the file tree: a server-mode import leaves .beads untouched
// even when it succeeds, so the issue count and the registry are compared too.
//
// `backup status` and `list` only read, and stay allowed;
// TestBackupStatusAndListWorkInReadonlyMode pins that. `bd backup` on its own is
// a command group that only prints help, and is left as it is.
// backupImportSurface is one command that strict --readonly must refuse.
type backupImportSurface struct {
name string
// args are the command and its arguments; the test appends the global flags.
args []string
// op is the operation label the gate reports.
op string
}
func backupImportSurfaces(w *readonlyGateWorkspace) []backupImportSurface {
return []backupImportSurface{
// A destination other than the registered one, so a run that goes
// through shows up as a changed registry.
{name: "backup-init", args: []string{"backup", "init", filepath.Join(w.dir, "other-backup-dest")}, op: "backup init"},
{name: "backup-remove", args: []string{"backup", "remove"}, op: "backup remove"},
{name: "backup-sync", args: []string{"backup", "sync"}, op: "backup sync"},
{name: "import", args: []string{"import", w.importFile}, op: "import"},
// A preview writes nothing, but strict --readonly already refuses
// `create --dry-run`, so import's is refused the same way.
{name: "import-dry-run", args: []string{"import", "--dry-run", w.importFile}, op: "import"},
}
}
// readonlyGateFlagSets are the global flag combinations every row runs under.
// --sandbox changes how bd treats the store (it disables auto-push); the gate
// has to hold with it as well.
var readonlyGateFlagSets = []struct {
name string
flags []string
}{
{name: "readonly", flags: []string{"--readonly"}},
{name: "readonly-sandbox", flags: []string{"--readonly", "--sandbox"}},
}
// readonlyGateFlavours are the two stores the gate has to hold over.
var readonlyGateFlavours = []struct {
name string
setup func(*testing.T) *readonlyGateWorkspace
}{
{name: "embedded", setup: newEmbeddedReadonlyGateWorkspace},
{name: "server", setup: newServerReadonlyGateWorkspace},
}
// readonlyGateWorkspace is an initialized workspace holding one issue and one
// registered backup, plus what a refused command has to leave alone.
type readonlyGateWorkspace struct {
bd, dir string
prefix string
dest string // directory behind the registered default backup
importFile string // a one-issue JSONL file for `bd import`
// Server flavour only: the shared test server and this workspace's database
// on it. A zero port means the embedded flavour.
port int
database string
}
// readonlyGateState is everything a refused command could have changed.
type readonlyGateState struct {
tree readonlyTreeSnapshot // the whole .beads directory
dest readonlyTreeSnapshot // the backup destination
issues int // what `bd list` reports
registry string // server flavour only: dolt_backups as name=url rows
}
func newEmbeddedReadonlyGateWorkspace(t *testing.T) *readonlyGateWorkspace {
t.Helper()
bd, dir := setupMigrationFreezeWorkspace(t)
w := &readonlyGateWorkspace{bd: bd, dir: dir, prefix: "test"}
w.seed(t)
return w
}
// newServerReadonlyGateWorkspace is the same workspace on the shared Dolt test
// server. The default lane starts none, so it skips there, as the other
// server-mode readonly test in this package does.
func newServerReadonlyGateWorkspace(t *testing.T) *readonlyGateWorkspace {
t.Helper()
port, err := strconv.Atoi(os.Getenv("BEADS_DOLT_PORT"))
if err != nil || port <= 0 {
t.Skip("shared Dolt test server is unavailable")
}
dir := t.TempDir()
bd := buildBDForInitTests(t)
runGitForBootstrapTest(t, dir, "init", "-q")
runGitForBootstrapTest(t, dir, "config", "core.hooksPath", ".git/hooks")
// The prefix names the database on the shared server, so it must be unique.
prefix := "rog" + strings.TrimPrefix(uniqueTestDBName(t), "testdb_")
stdout, stderr, code := runBDMigrationFreeze(t, bd, dir, "init", "--server", "--server-host", "127.0.0.1",
"--server-port", strconv.Itoa(port), "--external", "--prefix", prefix,
"--quiet", "--non-interactive", "--skip-hooks", "--skip-agents")
if code != 0 {
t.Fatalf("bd init --server failed (exit %d):\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
var meta struct {
Database string `json:"dolt_database"`
}
data, err := os.ReadFile(filepath.Join(dir, ".beads", "metadata.json"))
if err != nil {
t.Fatalf("reading metadata.json: %v", err)
}
if err := json.Unmarshal(data, &meta); err != nil || meta.Database == "" {
t.Fatalf("metadata.json names no dolt_database (%v):\n%s", err, data)
}
t.Cleanup(func() {
db, err := sql.Open("mysql", doltutil.ServerDSN{Host: "127.0.0.1", Port: port, User: "root"}.String())
if err != nil {
return
}
defer db.Close()
_, _ = db.ExecContext(context.Background(), fmt.Sprintf("DROP DATABASE IF EXISTS `%s`", meta.Database)) //nolint:gosec // generated test name
})
w := &readonlyGateWorkspace{bd: bd, dir: dir, prefix: prefix, port: port, database: meta.Database}
w.seed(t)
return w
}
// seed gives the workspace one issue, one registered backup and a JSONL file
// whose single issue is not in the workspace yet.
func (w *readonlyGateWorkspace) seed(t *testing.T) {
t.Helper()
w.dest = filepath.Join(w.dir, "backup-dest")
w.importFile = filepath.Join(w.dir, "import.jsonl")
record := fmt.Sprintf(`{"id":"%s-gate1","title":"imported under readonly","status":"open","priority":2,"issue_type":"task","created_at":"2026-01-01T00:00:00Z"}`+"\n", w.prefix)
if err := os.WriteFile(w.importFile, []byte(record), 0o644); err != nil {
t.Fatalf("writing %s: %v", w.importFile, err)
}
if stdout, stderr, code := w.run(t, "create", "seed issue", "-p", "2"); code != 0 {
t.Fatalf("bd create failed (exit %d):\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
w.registerBackup(t)
}
func (w *readonlyGateWorkspace) run(t *testing.T, args ...string) (stdout, stderr string, exitCode int) {
t.Helper()
return runBDMigrationFreeze(t, w.bd, w.dir, args...)
}
// registerBackup points the default backup at w.dest. Rows call it before each
// run: a row that went through when it should have been refused may have moved
// or removed the backup, and the next row still needs one to be refused against.
func (w *readonlyGateWorkspace) registerBackup(t *testing.T) {
t.Helper()
if stdout, stderr, code := w.run(t, "backup", "init", "file://"+w.dest); code != 0 {
t.Fatalf("bd backup init failed (exit %d):\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
}
func (w *readonlyGateWorkspace) state(t *testing.T) readonlyGateState {
t.Helper()
// Count the issues first: that is itself a strict --readonly read, so
// anything it creates lazily exists before the snapshot instead of showing
// up in it as a change.
s := readonlyGateState{issues: w.issueCount(t)}
s.tree = snapshotReadonlyTree(t, filepath.Join(w.dir, ".beads"))
s.dest = snapshotReadonlyTree(t, w.dest)
if w.port != 0 {
s.registry = w.backupRegistry(t)
}
return s
}
func (w *readonlyGateWorkspace) issueCount(t *testing.T) int {
t.Helper()
stdout, stderr, code := w.run(t, "list", "--json", "--readonly")
if code != 0 {
t.Fatalf("bd list failed (exit %d):\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
var issues []json.RawMessage
if err := json.Unmarshal([]byte(stdout), &issues); err != nil {
t.Fatalf("bd list --json is not a JSON array: %v\n%s", err, stdout)
}
return len(issues)
}
// backupRegistry reads the backups the server has registered for this
// workspace's database. No bd command prints them, and the file tree never
// shows them, so a refused run is checked against the server itself.
func (w *readonlyGateWorkspace) backupRegistry(t *testing.T) string {
t.Helper()
db, err := sql.Open("mysql", doltutil.ServerDSN{Host: "127.0.0.1", Port: w.port, User: "root", Database: w.database}.String())
if err != nil {
t.Fatalf("connecting to the test server: %v", err)
}
defer db.Close()
rows, err := db.QueryContext(context.Background(), "SELECT name, url FROM dolt_backups ORDER BY name")
if err != nil {
t.Fatalf("reading dolt_backups: %v", err)
}
defer rows.Close()
var lines []string
for rows.Next() {
var name, url string
if err := rows.Scan(&name, &url); err != nil {
t.Fatalf("scanning dolt_backups: %v", err)
}
lines = append(lines, name+"="+url)
}
if err := rows.Err(); err != nil {
t.Fatalf("reading dolt_backups: %v", err)
}
return strings.Join(lines, "\n")
}
// assertUnchanged proves a refusal happened before any mutation, not merely
// that the refusal text was printed.
func (w *readonlyGateWorkspace) assertUnchanged(t *testing.T, before readonlyGateState) {
t.Helper()
after := w.state(t)
if diff := readonlyTreeDiff(before.tree, after.tree); len(diff) > 0 {
t.Errorf("a refused run changed .beads:\n %s", strings.Join(diff, "\n "))
}
if diff := readonlyTreeDiff(before.dest, after.dest); len(diff) > 0 {
t.Errorf("a refused run changed the backup destination:\n %s", strings.Join(diff, "\n "))
}
if after.issues != before.issues {
t.Errorf("a refused run changed the issue count: %d -> %d", before.issues, after.issues)
}
if after.registry != before.registry {
t.Errorf("a refused run changed the backup registry:\nbefore:\n%s\nafter:\n%s", before.registry, after.registry)
}
}
// readonlyTreeDiff names what differs between two snapshots, so a leaked
// mutation reads as "+ backup.lock" rather than as two opaque hash maps.
func readonlyTreeDiff(before, after readonlyTreeSnapshot) []string {
var diff []string
if before.Exists != after.Exists {
diff = append(diff, fmt.Sprintf("exists: %t -> %t", before.Exists, after.Exists))
}
for path, was := range before.Entries {
if now, ok := after.Entries[path]; !ok {
diff = append(diff, "- "+path)
} else if now != was {
diff = append(diff, "~ "+path)
}
}
for path := range after.Entries {
if _, ok := before.Entries[path]; !ok {
diff = append(diff, "+ "+path)
}
}
sort.Strings(diff)
return diff
}
// TestBackupAndImportBlockedInReadonlyMode is the readonly gate for the backup
// and import commands. One workspace per flavour serves every row; each row
// re-registers the backup first, so none depends on what the previous one did.
func TestBackupAndImportBlockedInReadonlyMode(t *testing.T) {
for _, flavour := range readonlyGateFlavours {
t.Run(flavour.name, func(t *testing.T) {
w := flavour.setup(t)
for _, tt := range backupImportSurfaces(w) {
t.Run(tt.name, func(t *testing.T) {
for _, flagSet := range readonlyGateFlagSets {
t.Run(flagSet.name, func(t *testing.T) {
w.registerBackup(t)
before := w.state(t)
args := append(append([]string{}, tt.args...), flagSet.flags...)
stdout, stderr, code := w.run(t, args...)
want := "Error: operation '" + tt.op + "' is not allowed in read-only mode\n"
if code != 1 {
t.Errorf("exit code = %d, want 1\nstdout:\n%s\nstderr:\n%s", code, stdout, stderr)
}
if stderr != want {
t.Errorf("stderr is not exactly the standard refusal\ngot: %q\nwant: %q", stderr, want)
}
if stdout != "" {
t.Errorf("stdout should be empty when the command is refused, got:\n%s", stdout)
}
w.assertUnchanged(t, before)
})
}
})
}
})
}
}
// TestDoctorDiagnosisWorksInReadonlyMode pins the other half of the contract:
// the gate keys on --fix/--clean alone, so every diagnosis mode still runs
// under --readonly. Diagnosing a sandboxed workspace is the whole point.
@ -455,25 +143,6 @@ func TestDoctorDiagnosisWorksInReadonlyMode(t *testing.T) {
}
}
// TestBackupStatusAndListWorkInReadonlyMode is the control for the backup and
// import gate: it keys on the commands that write, so `backup status` and
// `list` still run under --readonly, in both flavours.
func TestBackupStatusAndListWorkInReadonlyMode(t *testing.T) {
for _, flavour := range readonlyGateFlavours {
t.Run(flavour.name, func(t *testing.T) {
w := flavour.setup(t)
for _, args := range [][]string{{"backup", "status"}, {"list"}} {
t.Run(strings.Join(args, "_"), func(t *testing.T) {
stdout, stderr, code := w.run(t, append(append([]string{}, args...), "--readonly")...)
if code != 0 || strings.Contains(stderr, "not allowed in read-only mode") {
t.Errorf("bd %v under --readonly should run (exit %d):\nstdout:\n%s\nstderr:\n%s", args, code, stdout, stderr)
}
})
}
})
}
}
// TestDoctorMaintenanceSkippedInReadonlyMode is the readonly twin of
// TestDoctorMaintenanceSkippedDuringMigrationFreeze — see that test for why
// plain `bd doctor` had hidden writes at all, and for the shared-server setup.

View file

@ -1124,11 +1124,6 @@ is shown as not running, and the next bd command launches it.`,
if beadsDir == "" {
return HandleErrorWithHint(activeWorkspaceNotFoundError(), diagHint())
}
// A workspace in a format this build cannot open is refused before
// configfile.Load, which would first migrate a legacy config.json.
if err := checkDiscoveredWorkspaceFormat(beadsDir); err != nil {
return handleWorkspaceGuardError(err)
}
cfg, cfgErr := configfile.Load(beadsDir)
if cfgErr != nil {
return HandleError("loading config: %v", cfgErr)
@ -2009,11 +2004,6 @@ func showDoltConfig(testConnection bool) error {
return HandleErrorWithHint(activeWorkspaceNotFoundError(), diagHint())
}
// A workspace in a format this build cannot open is refused before
// configfile.Load, which would first migrate a legacy config.json.
if err := checkDiscoveredWorkspaceFormat(beadsDir); err != nil {
return handleWorkspaceGuardError(err)
}
cfg, err := configfile.Load(beadsDir)
if err != nil {
return HandleError("loading config: %v", err)

View file

@ -41,7 +41,7 @@ func bdDoltSeparate(t *testing.T, bd, dir string, args ...string) (string, strin
// -- push --
func TestEmbeddedDoltLocalOnly_Push_ExitsZeroWithMessage(t *testing.T) {
func TestDoltLocalOnly_Push_ExitsZeroWithMessage(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
}
@ -62,7 +62,7 @@ func TestEmbeddedDoltLocalOnly_Push_ExitsZeroWithMessage(t *testing.T) {
}
}
func TestEmbeddedDoltLocalOnly_Push_LocalStoreCopy(t *testing.T) {
func TestDoltLocalOnly_Push_LocalStoreCopy(t *testing.T) {
// The push no-op message must include the "Your issues are stored locally" line.
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
@ -77,7 +77,7 @@ func TestEmbeddedDoltLocalOnly_Push_LocalStoreCopy(t *testing.T) {
}
}
func TestEmbeddedDoltLocalOnly_Push_JSON_DisabledStatus(t *testing.T) {
func TestDoltLocalOnly_Push_JSON_DisabledStatus(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
}
@ -101,7 +101,7 @@ func TestEmbeddedDoltLocalOnly_Push_JSON_DisabledStatus(t *testing.T) {
// -- pull --
func TestEmbeddedDoltLocalOnly_Pull_ExitsZeroWithMessage(t *testing.T) {
func TestDoltLocalOnly_Pull_ExitsZeroWithMessage(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
}
@ -122,7 +122,7 @@ func TestEmbeddedDoltLocalOnly_Pull_ExitsZeroWithMessage(t *testing.T) {
}
}
func TestEmbeddedDoltLocalOnly_Pull_JSON_DisabledStatus(t *testing.T) {
func TestDoltLocalOnly_Pull_JSON_DisabledStatus(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
}
@ -146,7 +146,7 @@ func TestEmbeddedDoltLocalOnly_Pull_JSON_DisabledStatus(t *testing.T) {
// -- remote add --
func TestEmbeddedDoltLocalOnly_RemoteAdd_RefusesExitOne(t *testing.T) {
func TestDoltLocalOnly_RemoteAdd_RefusesExitOne(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
}
@ -169,7 +169,7 @@ func TestEmbeddedDoltLocalOnly_RemoteAdd_RefusesExitOne(t *testing.T) {
}
}
func TestEmbeddedDoltLocalOnly_RemoteAdd_ErrorOnStderr(t *testing.T) {
func TestDoltLocalOnly_RemoteAdd_ErrorOnStderr(t *testing.T) {
// The refusal must go to stderr (not stdout) so agents can distinguish errors.
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
@ -189,7 +189,7 @@ func TestEmbeddedDoltLocalOnly_RemoteAdd_ErrorOnStderr(t *testing.T) {
// -- config round-trip --
func TestEmbeddedDoltLocalOnly_ConfigRoundTrip(t *testing.T) {
func TestDoltLocalOnly_ConfigRoundTrip(t *testing.T) {
// bd config set dolt.local-only true / unset must persist via config.yaml.
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")
@ -215,7 +215,7 @@ func TestEmbeddedDoltLocalOnly_ConfigRoundTrip(t *testing.T) {
// -- bd dolt status --
func TestEmbeddedDoltLocalOnly_DoltStatus_ShowsDisabled(t *testing.T) {
func TestDoltLocalOnly_DoltStatus_ShowsDisabled(t *testing.T) {
// When dolt.local-only=true, bd dolt status must include the indicator line.
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run dolt.local-only embedded tests")

View file

@ -2,6 +2,7 @@ package main
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"testing"
@ -107,6 +108,28 @@ func TestCollectProxiedDoltStatusExternalTopology(t *testing.T) {
}
}
// TestCollectProxiedDoltStatusLegacySidecarReportsDefaultIdleTimeout covers a
// workspace provisioned before the sidecar persisted its effective idle
// timeout: the key is absent on disk, yet the proxy still reaps at the default.
// Status must report that default as it does for a fresh workspace, not drop
// the field as if no timeout applied (bd-mnhq6).
func TestCollectProxiedDoltStatusLegacySidecarReportsDefaultIdleTimeout(t *testing.T) {
beadsDir := t.TempDir()
root := filepath.Join(beadsDir, "dolt")
t.Setenv("BEADS_PROXIED_SERVER_ROOT_PATH", root)
if err := os.WriteFile(configfile.ProxiedServerClientInfoPath(beadsDir), []byte(`{}`), 0o600); err != nil {
t.Fatalf("seed legacy sidecar: %v", err)
}
status, err := collectProxiedDoltStatus(beadsDir)
if err != nil {
t.Fatalf("collectProxiedDoltStatus: %v", err)
}
if want := configfile.DefaultProxyIdleTimeout.String(); status.IdleTimeout != want {
t.Errorf("idle_timeout = %q, want %q", status.IdleTimeout, want)
}
}
func TestRenderProxiedDoltStatus(t *testing.T) {
running := proxiedDoltStatus{
Mode: "proxied-server", Root: "/w/.beads/dolt", Running: true,

View file

@ -1,19 +1,21 @@
//go:build cgo
//go:build embeddeddolt && cgo
package main
import (
"bytes"
"encoding/json"
"os"
"os/exec"
"strings"
"testing"
)
// Integration tests for be-7eu1d's git-origin collision guard in bd dolt
// remote add (FR-06, FR-07). Its bd doctor half (FR-08, FR-09:
// doctor.CheckDoltRemoteGitOrigin) is server-mode only: bd doctor runs none of
// its checks on an embedded workspace (GH#3794), so it cannot be driven here.
// Integration tests for be-7eu1d: git-origin collision guard in bd dolt remote
// add and bd doctor (FR-06 to FR-09).
//
// TDD gate tests — these fail before the implementation exists. Run with
// BEADS_TEST_EMBEDDED_DOLT=1.
// remoteAdd runs "bd dolt remote add <args>" returning (stdout, stderr, error)
// with separate buffers. Delegates to bdDoltSeparate (dolt_local_only_embedded_test.go).
@ -32,11 +34,25 @@ func setGitOrigin(t *testing.T, dir, url string) {
}
}
// bdDoctorSeparate runs "bd doctor <args>" returning (stdout, stderr, error).
func bdDoctorSeparate(t *testing.T, bd, dir string, args ...string) (string, string, error) {
t.Helper()
fullArgs := append([]string{"doctor"}, args...)
cmd := exec.Command(bd, fullArgs...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
var stdout, stderr bytes.Buffer
cmd.Stdout = &stdout
cmd.Stderr = &stderr
err := cmd.Run()
return stdout.String(), stderr.String(), err
}
// -- bd dolt remote add: collision with git origin --
// TestEmbeddedDoltRemoteAdd_GitOriginCollision_Exits1 asserts that adding a Dolt remote
// TestDoltRemoteAdd_GitOriginCollision_Exits1 asserts that adding a Dolt remote
// whose URL matches the git origin exits non-zero and prints the refusal message.
func TestEmbeddedDoltRemoteAdd_GitOriginCollision_Exits1(t *testing.T) {
func TestDoltRemoteAdd_GitOriginCollision_Exits1(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -59,9 +75,9 @@ func TestEmbeddedDoltRemoteAdd_GitOriginCollision_Exits1(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy verifies exact phrases
// TestDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy verifies exact phrases
// from the UX spec (be-fxwbm §2.1) appear in the refusal output.
func TestEmbeddedDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy(t *testing.T) {
func TestDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -87,9 +103,9 @@ func TestEmbeddedDoltRemoteAdd_GitOriginCollision_RefusalMessageCopy(t *testing.
}
}
// TestEmbeddedDoltRemoteAdd_AllowGitOrigin_Exits0 asserts that --allow-git-origin
// TestDoltRemoteAdd_AllowGitOrigin_Exits0 asserts that --allow-git-origin
// bypasses the collision guard and exits 0.
func TestEmbeddedDoltRemoteAdd_AllowGitOrigin_Exits0(t *testing.T) {
func TestDoltRemoteAdd_AllowGitOrigin_Exits0(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -106,9 +122,9 @@ func TestEmbeddedDoltRemoteAdd_AllowGitOrigin_Exits0(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_AllowGitOrigin_WarningOnStderr asserts the one-liner warning
// TestDoltRemoteAdd_AllowGitOrigin_WarningOnStderr asserts the one-liner warning
// from be-fxwbm §2.2 appears on stderr when --allow-git-origin is set.
func TestEmbeddedDoltRemoteAdd_AllowGitOrigin_WarningOnStderr(t *testing.T) {
func TestDoltRemoteAdd_AllowGitOrigin_WarningOnStderr(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -130,9 +146,9 @@ func TestEmbeddedDoltRemoteAdd_AllowGitOrigin_WarningOnStderr(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_NoGitOrigin_ProceedsNormally asserts no refusal fires when
// TestDoltRemoteAdd_NoGitOrigin_ProceedsNormally asserts no refusal fires when
// the git repo has no 'origin' remote.
func TestEmbeddedDoltRemoteAdd_NoGitOrigin_ProceedsNormally(t *testing.T) {
func TestDoltRemoteAdd_NoGitOrigin_ProceedsNormally(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -151,9 +167,9 @@ func TestEmbeddedDoltRemoteAdd_NoGitOrigin_ProceedsNormally(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_DifferentURL_ProceedsNormally asserts the guard does not
// TestDoltRemoteAdd_DifferentURL_ProceedsNormally asserts the guard does not
// fire when the Dolt remote URL is different from the git origin.
func TestEmbeddedDoltRemoteAdd_DifferentURL_ProceedsNormally(t *testing.T) {
func TestDoltRemoteAdd_DifferentURL_ProceedsNormally(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -174,10 +190,10 @@ func TestEmbeddedDoltRemoteAdd_DifferentURL_ProceedsNormally(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_LocalOnly_FiresBeforeGuard verifies that when
// TestDoltRemoteAdd_LocalOnly_FiresBeforeGuard verifies that when
// dolt.local-only=true is set, the local-only refusal fires before the
// git-origin guard — the local-only guard takes priority (be-3v2ou ordering).
func TestEmbeddedDoltRemoteAdd_LocalOnly_FiresBeforeGuard(t *testing.T) {
func TestDoltRemoteAdd_LocalOnly_FiresBeforeGuard(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -202,9 +218,130 @@ func TestEmbeddedDoltRemoteAdd_LocalOnly_FiresBeforeGuard(t *testing.T) {
}
}
// TestEmbeddedDoltRemoteAdd_JSON_AllowGitOrigin_WarningOnStderr asserts that even in
// -- bd doctor: Dolt remote matches git origin --
// TestDoctor_DoltRemoteMatchesGitOrigin_Warning verifies that bd doctor emits a
// warning when a Dolt remote URL matches the git origin.
func TestDoctor_DoltRemoteMatchesGitOrigin_Warning(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "dw")
originURL := "file:///tmp/origin-collision-for-doctor"
setGitOrigin(t, dir, originURL)
// Add a Dolt remote that matches the git origin (using --allow-git-origin to bypass the guard).
bdDolt(t, bd, dir, "remote", "add", "--allow-git-origin", "origin", originURL)
stdout, _, _ := bdDoctorSeparate(t, bd, dir)
combined := stdout
// Doctor must surface the warning check.
if !strings.Contains(combined, "warning") && !strings.Contains(combined, "Warning") {
t.Errorf("bd doctor: expected warning when Dolt remote matches git origin\noutput:\n%s", combined)
}
if !strings.Contains(combined, "git origin") {
t.Errorf("bd doctor: expected 'git origin' in warning output\noutput:\n%s", combined)
}
}
// TestDoctor_DoltRemoteNoMatch_OK verifies that bd doctor does NOT emit a
// git-origin warning when the Dolt remote URL differs from the git origin.
func TestDoctor_DoltRemoteNoMatch_OK(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "dn")
setGitOrigin(t, dir, "https://github.com/org/repo.git")
remoteDir := t.TempDir()
bdDolt(t, bd, dir, "remote", "add", "dolt-origin", "file://"+remoteDir)
stdout, _, _ := bdDoctorSeparate(t, bd, dir)
if strings.Contains(stdout, "Dolt remote matches git origin") {
t.Errorf("bd doctor: unexpected git-origin warning when URLs differ\noutput:\n%s", stdout)
}
}
// TestDoctor_NoGitOrigin_OK verifies that bd doctor shows OK for the git-origin
// check when no git origin is configured.
func TestDoctor_NoGitOrigin_OK(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "ng")
// bdInit creates a git repo but no origin.
remoteDir := t.TempDir()
bdDolt(t, bd, dir, "remote", "add", "dolt-origin", "file://"+remoteDir)
stdout, _, _ := bdDoctorSeparate(t, bd, dir)
// Should not emit a warning for the git-origin check.
if strings.Contains(stdout, "Dolt remote matches git origin") {
t.Errorf("bd doctor: unexpected git-origin warning when no git origin\noutput:\n%s", stdout)
}
}
// TestDoctor_JSON_DoltRemoteMatchesGitOrigin_Warning verifies that
// bd doctor --json exposes the git-origin warning check with "status":"warning".
func TestDoctor_JSON_DoltRemoteMatchesGitOrigin_Warning(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "dj")
originURL := "file:///tmp/origin-collision-for-json"
setGitOrigin(t, dir, originURL)
bdDolt(t, bd, dir, "remote", "add", "--allow-git-origin", "origin", originURL)
stdout, _, _ := bdDoctorSeparate(t, bd, dir, "--json")
// Output should be JSON array of checks.
var checks []map[string]interface{}
if err := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &checks); err != nil {
// May be wrapped in an outer object — try extracting the checks array.
var outer map[string]interface{}
if jsonErr := json.Unmarshal([]byte(strings.TrimSpace(stdout)), &outer); jsonErr != nil {
t.Fatalf("bd doctor --json: not valid JSON: %v\noutput:\n%s", err, stdout)
}
if arr, ok := outer["checks"].([]interface{}); ok {
data, _ := json.Marshal(arr)
_ = json.Unmarshal(data, &checks)
}
}
found := false
for _, check := range checks {
name, _ := check["name"].(string)
if strings.Contains(name, "git origin") || strings.Contains(name, "Dolt remote") {
found = true
status, _ := check["status"].(string)
if status != "warning" {
t.Errorf("doctor JSON check %q: status = %q, want \"warning\"", name, status)
}
if _, hasFix := check["fix"]; !hasFix {
t.Errorf("doctor JSON check %q: missing \"fix\" field", name)
}
break
}
}
if !found {
t.Errorf("bd doctor --json: no git-origin check found in output\noutput:\n%s", stdout)
}
}
// TestDoltRemoteAdd_JSON_AllowGitOrigin_WarningOnStderr asserts that even in
// --json mode, the override warning still appears on stderr (not stdout).
func TestEmbeddedDoltRemoteAdd_JSON_AllowGitOrigin_WarningOnStderr(t *testing.T) {
func TestDoltRemoteAdd_JSON_AllowGitOrigin_WarningOnStderr(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}

View file

@ -56,7 +56,7 @@ func lsRemoteRef(t *testing.T, remoteDir, ref string) string {
return fields[0]
}
func TestEmbeddedDoltRemoteResetData_GitBacked(t *testing.T) {
func TestDoltRemoteResetData_GitBacked(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -112,7 +112,7 @@ func TestEmbeddedDoltRemoteResetData_GitBacked(t *testing.T) {
}
}
func TestEmbeddedDoltRemoteResetData_UnknownRemote(t *testing.T) {
func TestDoltRemoteResetData_UnknownRemote(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}
@ -129,7 +129,7 @@ func TestEmbeddedDoltRemoteResetData_UnknownRemote(t *testing.T) {
}
}
func TestEmbeddedDoltRemoteResetData_CloudRemoteRefused(t *testing.T) {
func TestDoltRemoteResetData_CloudRemoteRefused(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded integration tests")
}

View file

@ -13,7 +13,7 @@ import (
"github.com/steveyegge/beads/internal/storage"
)
// TestEmbeddedAutoPruneBoundsTheJournalAfterAMutatingCommand is the feature as a user
// TestAutoPruneBoundsTheJournalAfterAMutatingCommand is the feature as a user
// meets it: enable the journal, write, and the journal stays inside its floors
// without anyone running `bd events prune`.
//
@ -30,7 +30,7 @@ import (
// because the throttle's persisted watermark is never stamped while auto-prune
// is off, so the next command with it on is the first pass this workspace has
// ever run.
func TestEmbeddedAutoPruneBoundsTheJournalAfterAMutatingCommand(t *testing.T) {
func TestAutoPruneBoundsTheJournalAfterAMutatingCommand(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -117,12 +117,12 @@ func TestEmbeddedAutoPruneBoundsTheJournalAfterAMutatingCommand(t *testing.T) {
}
}
// TestEmbeddedAutoPruneLeavesAnUnboundedJournalAlone. Both floors at 0 is the documented
// TestAutoPruneLeavesAnUnboundedJournalAlone. Both floors at 0 is the documented
// way to keep every record, and it is also the configuration the truncation
// tests run under — so a maintenance pass that ignored it would quietly delete
// the history those tests (and any consumer that chose an unbounded ledger)
// depend on.
func TestEmbeddedAutoPruneLeavesAnUnboundedJournalAlone(t *testing.T) {
func TestAutoPruneLeavesAnUnboundedJournalAlone(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -158,7 +158,7 @@ func TestEmbeddedAutoPruneLeavesAnUnboundedJournalAlone(t *testing.T) {
}
}
// TestEmbeddedAutoPruneRespectsBdConfigSet drives the whole retention story through
// TestAutoPruneRespectsBdConfigSet drives the whole retention story through
// `bd config set` rather than the environment.
//
// The four events-journal keys are startup settings read through viper before
@ -167,7 +167,7 @@ func TestEmbeddedAutoPruneLeavesAnUnboundedJournalAlone(t *testing.T) {
// `bd config set events-journal true` reported success and changed nothing.
// A new key is one YamlOnlyKeys entry away from repeating it, and the symptom
// is invisible: retention that silently keeps whatever the default was.
func TestEmbeddedAutoPruneRespectsBdConfigSet(t *testing.T) {
func TestAutoPruneRespectsBdConfigSet(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -221,7 +221,7 @@ func TestEmbeddedAutoPruneRespectsBdConfigSet(t *testing.T) {
}
}
// TestEmbeddedAutoPruneDoesNotRunForReadOnlyCommands. The trigger is writer-pays, and
// TestAutoPruneDoesNotRunForReadOnlyCommands. The trigger is writer-pays, and
// three separate gates keep it that way — each one covered here by a command
// that would prune the journal without it:
//
@ -236,7 +236,7 @@ func TestEmbeddedAutoPruneRespectsBdConfigSet(t *testing.T) {
// - `bd migrate --dry-run` is a PREVIEW. It promised not to mutate and holds
// a write-refusing store; maintenance must not be the one write it
// performs.
func TestEmbeddedAutoPruneDoesNotRunForReadOnlyCommands(t *testing.T) {
func TestAutoPruneDoesNotRunForReadOnlyCommands(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -34,7 +34,7 @@ func runBDOut(t *testing.T, bd, dir string, env []string, args ...string) (strin
return stdout.String(), stderr.String()
}
// TestEmbeddedDeleteJournalsTheRequestingActor is #5985's repro, verbatim: create two
// TestDeleteJournalsTheRequestingActor is #5985's repro, verbatim: create two
// beads with an edge between them, delete the blocker with an explicit --actor,
// and read the journal back. Both the delete record and the cascade dep_remove
// record must name that actor.
@ -42,7 +42,7 @@ func runBDOut(t *testing.T, bd, dir string, env []string, args ...string) (strin
// The whole route is exercised — cobra flag to journal column — because the
// actor is resolved, threaded through the role, and written by the storage
// seam, and a unit test at any one of those cannot see the drop at the next.
func TestEmbeddedDeleteJournalsTheRequestingActor(t *testing.T) {
func TestDeleteJournalsTheRequestingActor(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -92,13 +92,13 @@ func TestEmbeddedDeleteJournalsTheRequestingActor(t *testing.T) {
}
}
// TestEmbeddedEventsReadNoticesADisabledJournal pins the "nothing to read and no way to
// TestEventsReadNoticesADisabledJournal pins the "nothing to read and no way to
// tell why" fix. A workspace that never enabled the journal serves an empty
// export forever, which a consumer cannot distinguish from being caught up, so
// the read says so on stderr — and keeps stdout clean and the exit status zero,
// because exporting a historical ledger from a now-disabled workspace is
// legitimate.
func TestEmbeddedEventsReadNoticesADisabledJournal(t *testing.T) {
func TestEventsReadNoticesADisabledJournal(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -118,7 +118,7 @@ func eventsJournalMaintenanceRunnerFor(plumbing any) issueops.EventsMaintenanceR
// with OpenForReadOnlyCommand, which is "otherwise a normal writable
// store", so nothing underneath refuses a maintenance delete. Drop this
// check and `bd list` prunes the journal — which
// TestEmbeddedAutoPruneDoesNotRunForReadOnlyCommands catches.
// TestAutoPruneDoesNotRunForReadOnlyCommands catches.
//
// Two more gates are specific to this trigger:
//

View file

@ -57,7 +57,7 @@ func TestProxiedServerServeActivatesTheEventsJournal(t *testing.T) {
}
}
// TestEmbeddedRoutedCreateJournalsIntoTheTargetWorkspace covers the cross-workspace
// TestRoutedCreateJournalsIntoTheTargetWorkspace covers the cross-workspace
// store: `bd create --repo <other>` opens a SECOND store for another workspace
// and writes the bead there.
//
@ -65,7 +65,7 @@ func TestProxiedServerServeActivatesTheEventsJournal(t *testing.T) {
// TARGET's own config.yaml, so a workspace that enabled the journal gets its
// mutations recorded no matter which directory bd was launched from — and the
// launching workspace, which enabled nothing, records nothing of its own.
func TestEmbeddedRoutedCreateJournalsIntoTheTargetWorkspace(t *testing.T) {
func TestRoutedCreateJournalsIntoTheTargetWorkspace(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -120,13 +120,13 @@ func TestEmbeddedRoutedCreateJournalsIntoTheTargetWorkspace(t *testing.T) {
}
}
// TestEmbeddedRoutedCreateHonorsTheEnvOverrideOverTheTargetsConfig is the precedence
// TestRoutedCreateHonorsTheEnvOverrideOverTheTargetsConfig is the precedence
// half. BD_EVENTS_JOURNAL is the documented way to turn the journal on for a
// process without editing a workspace, and a routed write is exactly where an
// operator reaches for it — so a target whose config.yaml says false must not
// be able to veto it. Getting this backwards makes the env var a suggestion,
// and the operator finds out by discovering an empty journal later.
func TestEmbeddedRoutedCreateHonorsTheEnvOverrideOverTheTargetsConfig(t *testing.T) {
func TestRoutedCreateHonorsTheEnvOverrideOverTheTargetsConfig(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -89,21 +89,15 @@ var qualifiedActivationCalls = map[string]map[string]bool{
// scannedPackages are the directories searched for construction sites: every
// package that builds a store or provider for the bd binary, plus the standalone
// embedded-Dolt utility and the Go SDK's own opens (the repository root), so they
// are accounted for rather than merely unnoticed. Each maps to the prefix its
// sites are keyed under.
// embedded-Dolt utility so it is accounted for rather than merely unnoticed.
// Each maps to the prefix its sites are keyed under.
var scannedPackages = map[string]string{
".": "",
"doctor": "doctor/",
"doctor/fix": "doctor/fix/",
"../../internal/storage/embeddeddolt/cmd": "embeddeddolt-cmd/",
"../..": "sdk/",
}
// sdkOpenExemptionReason is the one reason the Go SDK's five opens share. It has
// to be true of both per-store switches, because the exemption list is shared.
const sdkOpenExemptionReason = "SDK entry point (library surface, not the bd binary): applies neither per-store switch, the events journal's or versioned history's; the bd binary's factories do"
// constructionExemptions are construction sites that legitimately do NOT
// activate the events journal, each with a reason. Keyed by
// "<pkg>/<file>:<Recv.Func>" so the two build-tag twins of a factory are
@ -178,17 +172,6 @@ var constructionExemptions = map[string]string{
// A standalone developer utility binary, not bd. It has no workspace config
// to read and never runs as part of a bd command.
"embeddeddolt-cmd/main.go:main": "standalone embeddeddolt debug utility, not the bd binary; no workspace config and no bd command context",
// The Go SDK's own opens (the repository root's beads package). They are a
// library surface that embedders call directly, and they build stores without
// applying either per-store switch. They are declared here so that a new SDK
// open is noticed rather than missed. Making them apply the switches would
// change the library's behavior for every embedder, so it is a separate change.
"sdk/beads.go:Open": sdkOpenExemptionReason,
"sdk/beads.go:OpenFromConfig": sdkOpenExemptionReason,
"sdk/beads.go:OpenGated": sdkOpenExemptionReason,
"sdk/beads_cgo.go:OpenBestAvailableWith": sdkOpenExemptionReason,
"sdk/beads_nocgo.go:OpenBestAvailableWith": sdkOpenExemptionReason,
}
func TestEveryStoreConstructionActivatesTheEventsJournal(t *testing.T) {
@ -252,9 +235,6 @@ func exemptionFor(key string) (exemption, reason string, ok bool) {
type constructionSite struct {
constructors []string
activates bool
// activatesVersionedHistory is the same question for the versioned-history
// guard, which reuses this scan (see versioned_history_construction_test.go).
activatesVersionedHistory bool
}
// scanStoreConstructionSites parses each scanned package and returns one entry
@ -384,16 +364,10 @@ func inspectConstructionSite(node ast.Node, imports map[string]string) *construc
if qualifiedActivationCalls[path][fun.Sel.Name] {
site.activates = true
}
if qualifiedVersionedHistoryActivationCalls[path][fun.Sel.Name] {
site.activatesVersionedHistory = true
}
case *ast.Ident:
if activationCalls[fun.Name] {
site.activates = true
}
if versionedHistoryActivationCalls[fun.Name] {
site.activatesVersionedHistory = true
}
}
return true
})

View file

@ -3,6 +3,7 @@
package main
import (
"bytes"
"encoding/json"
"fmt"
"os"
@ -15,7 +16,7 @@ import (
"github.com/steveyegge/beads/internal/storage"
)
// TestEmbeddedEventsTailReportsTruncationToTheCLI is the end-to-end guard for the
// TestEventsTailReportsTruncationToTheCLI is the end-to-end guard for the
// retention boundary as a consumer actually meets it: through the binary, not
// through the store API.
//
@ -26,7 +27,7 @@ import (
// that; this one fails if either path regresses. It also proves the whole
// config chain end to end: BD_EVENTS_JOURNAL turns the journal on, and the two
// BD_EVENTS_JOURNAL_RETAIN_* floors reach the prune.
func TestEmbeddedEventsTailReportsTruncationToTheCLI(t *testing.T) {
func TestEventsTailReportsTruncationToTheCLI(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -108,7 +109,7 @@ func TestEmbeddedEventsTailReportsTruncationToTheCLI(t *testing.T) {
}
}
// TestEmbeddedEventsTailFollowReportsTruncationOnTheStream covers the OTHER read call
// TestEventsTailFollowReportsTruncationOnTheStream covers the OTHER read call
// site: the --follow poll, which the one-shot test above cannot reach.
//
// A follower is the consumer most exposed to a prune — it is the one sitting
@ -119,7 +120,7 @@ func TestEmbeddedEventsTailReportsTruncationToTheCLI(t *testing.T) {
// it interrupts. The consumer on the other end is a line reader; a
// pretty-printed multi-line object in the middle of its input is unparseable,
// and it would see the stream stop with garbage after the last good record.
func TestEmbeddedEventsTailFollowReportsTruncationOnTheStream(t *testing.T) {
func TestEventsTailFollowReportsTruncationOnTheStream(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -162,7 +163,7 @@ func TestEmbeddedEventsTailFollowReportsTruncationOnTheStream(t *testing.T) {
follow := exec.Command(bd, "events", "tail", "--since", "0", "--limit", "1", "--follow", "--json")
follow.Dir = dir
follow.Env = env
var stdout, stderr syncBuffer
var stdout, stderr bytes.Buffer
follow.Stdout = &stdout
follow.Stderr = &stderr
if err := follow.Start(); err != nil {
@ -225,11 +226,11 @@ func TestEmbeddedEventsTailFollowReportsTruncationOnTheStream(t *testing.T) {
}
}
// TestEmbeddedEventsPruneHonorsRetainRowsFloorFromConfig proves the shipped defaults
// TestEventsPruneHonorsRetainRowsFloorFromConfig proves the shipped defaults
// reach the CLI: a `prune --before <huge>` on a workspace that configured no
// floors of its own must be stopped by the built-in retain-rows floor rather
// than deleting the whole journal and stranding its consumer.
func TestEmbeddedEventsPruneHonorsRetainRowsFloorFromConfig(t *testing.T) {
func TestEventsPruneHonorsRetainRowsFloorFromConfig(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -47,9 +47,9 @@ func parseExportedIssues(t *testing.T, jsonl string) []*types.Issue {
return issues
}
// TestEmbeddedExportExcludeOwner_flag verifies that bd export --exclude-owner=<name>
// TestExportExcludeOwner_flag verifies that bd export --exclude-owner=<name>
// filters out issues created_by that identity from the export.
func TestEmbeddedExportExcludeOwner_flag(t *testing.T) {
func TestExportExcludeOwner_flag(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -86,9 +86,9 @@ func TestEmbeddedExportExcludeOwner_flag(t *testing.T) {
}
}
// TestEmbeddedExportExcludeOwner_config verifies that export.exclude_owners config
// TestExportExcludeOwner_config verifies that export.exclude_owners config
// filters issues without a command-line flag.
func TestEmbeddedExportExcludeOwner_config(t *testing.T) {
func TestExportExcludeOwner_config(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -115,8 +115,8 @@ func TestEmbeddedExportExcludeOwner_config(t *testing.T) {
}
}
// TestEmbeddedExportExcludeOwner_verbose verifies that --verbose emits a filtered count message.
func TestEmbeddedExportExcludeOwner_verbose(t *testing.T) {
// TestExportExcludeOwner_verbose verifies that --verbose emits a filtered count message.
func TestExportExcludeOwner_verbose(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
@ -151,12 +151,12 @@ func TestEmbeddedExportExcludeOwner_verbose(t *testing.T) {
}
}
// TestEmbeddedAutoExportExcludeOwner_config is a regression test for the maphew review
// TestAutoExportExcludeOwner_config is a regression test for the maphew review
// of PR #4023 (be-e2nb): the export.exclude_owners safety net must also apply to
// the git-committed auto-export (.beads/issues.jsonl), not only to manual
// `bd export`. Before the fix, contributor/personal issues that the manual path
// excludes could still leak into git history and PRs via auto-export.
func TestEmbeddedAutoExportExcludeOwner_config(t *testing.T) {
func TestAutoExportExcludeOwner_config(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}

View file

@ -1,102 +0,0 @@
//go:build cgo
package main
import (
"bytes"
"encoding/json"
"errors"
"os"
"os/exec"
"slices"
"strings"
"testing"
)
// bdRunStreams runs one bd process in dir with the hermetic test environment
// and returns stdout, stderr and the exit status separately. A nonzero exit is
// returned, not fatal, so a caller can pin the status itself; only a process
// that could not be started fails the test here.
func bdRunStreams(t *testing.T, bd, dir string, args ...string) (stdout, stderr string, exit int) {
t.Helper()
cmd := exec.Command(bd, args...)
cmd.Dir = dir
cmd.Env = bdEnv(dir)
var outBuf, errBuf bytes.Buffer
cmd.Stdout, cmd.Stderr = &outBuf, &errBuf
if err := cmd.Run(); err != nil {
var ee *exec.ExitError
if !errors.As(err, &ee) {
t.Fatalf("bd %s did not run: %v", strings.Join(args, " "), err)
}
return outBuf.String(), errBuf.String(), ee.ExitCode()
}
return outBuf.String(), errBuf.String(), 0
}
// TestEmbeddedFormatJSONAliasMatchesJSON pins the hidden root --format alias
// (GH#2612): on show, list, ready and memories, `--format json` prints exactly
// what `--json` prints, byte for byte, and exits 0 like it.
//
// The alias is a root persistent flag, so any subcommand that registers a
// --format of its own shadows it (the GH#6278 hazard). `bd list` already has
// its own --format and passes `json` through by hand (list_input.go). A
// local --format added to show, ready or memories for another output
// format would turn `bd show ID --format json` into a refusal or into a
// different document. Both are regressions this test catches: it compares
// the whole of stdout, not a parse of it.
//
// Each command is checked in three spellings: `--format json` and
// `--format=json` after the subcommand, and `--format json` before it, where
// the flag is plainly the root's.
func TestEmbeddedFormatJSONAliasMatchesJSON(t *testing.T) {
if os.Getenv("BEADS_TEST_EMBEDDED_DOLT") != "1" {
t.Skip("set BEADS_TEST_EMBEDDED_DOLT=1 to run embedded dolt integration tests")
}
t.Parallel()
bd := buildEmbeddedBD(t)
dir, _, _ := bdInit(t, bd, "--prefix", "fj")
id := bdCreateSilent(t, bd, dir, "Format alias parity", "--type", "task", "--description", "read through --format json")
bdRunOK(t, bd, dir, "remember", "the format alias is --json", "--key", "fj-alias")
for _, tc := range []struct {
name string
args []string
// mention is a value the --json document must contain, so two empty
// documents cannot match each other.
mention string
}{
{"show", []string{"show", id}, id},
{"list", []string{"list"}, id},
{"ready", []string{"ready"}, id},
{"memories", []string{"memories"}, "fj-alias"},
} {
t.Run(tc.name, func(t *testing.T) {
wantArgs := slices.Concat(tc.args, []string{"--json"})
want, wantErr, exit := bdRunStreams(t, bd, dir, wantArgs...)
if exit != 0 {
t.Fatalf("bd %s exited %d\nstdout:\n%s\nstderr:\n%s", strings.Join(wantArgs, " "), exit, want, wantErr)
}
if !json.Valid([]byte(want)) || !strings.Contains(want, tc.mention) {
t.Fatalf("bd %s did not print one JSON document naming %s:\n%s", strings.Join(wantArgs, " "), tc.mention, want)
}
for _, args := range [][]string{
slices.Concat(tc.args, []string{"--format", "json"}),
slices.Concat(tc.args, []string{"--format=json"}),
slices.Concat([]string{"--format", "json"}, tc.args),
} {
got, gotErr, exit := bdRunStreams(t, bd, dir, args...)
if exit != 0 {
t.Errorf("bd %s exited %d, want 0 like bd %s\nstdout:\n%s\nstderr:\n%s", strings.Join(args, " "), exit, strings.Join(wantArgs, " "), got, gotErr)
continue
}
if got != want {
t.Errorf("bd %s printed a different document from bd %s\n--format:\n%s\n--json:\n%s", strings.Join(args, " "), strings.Join(wantArgs, " "), got, want)
}
}
})
}
}

View file

@ -6,20 +6,16 @@ import (
"encoding/json"
"errors"
"fmt"
"math/rand/v2"
"os"
"os/exec"
"slices"
"strings"
"time"
"github.com/spf13/cobra"
"github.com/steveyegge/beads/internal/httpclient"
"github.com/steveyegge/beads/internal/httpclient/wire"
"github.com/steveyegge/beads/internal/metrics"
"github.com/steveyegge/beads/internal/storage"
storageissueops "github.com/steveyegge/beads/internal/storage/issueops"
"github.com/steveyegge/beads/internal/storage/uow"
"github.com/steveyegge/beads/internal/types"
"github.com/steveyegge/beads/internal/ui"
"github.com/steveyegge/beads/issueops"
@ -241,6 +237,9 @@ This is used by 'bd done --phase-complete' to register for gate wake notificatio
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
if usesProxiedServer() {
return runGateAddWaiterProxiedServer(cmd, rootCtx, args)
}
CheckReadonly("gate add-waiter")
evt := metrics.NewCommandEvent("gate-add-waiter")
@ -252,27 +251,34 @@ This is used by 'bd done --phase-complete' to register for gate wake notificatio
gateID := args[0]
waiter := args[1]
ctx := rootCtx
reader, err := openIssueReader()
var issue *types.Issue
var err error
issue, err = store.GetIssue(ctx, gateID)
if err != nil {
return HandleError("%v", err)
}
lifecycle, err := openIssueLifecycle()
if err != nil {
return HandleError("%v", err)
}
ctx, err := issueOpsContext(rootCtx)
if err != nil {
return HandleError("%v", err)
return HandleError("gate not found: %s", gateID)
}
added, err := addGateWaiter(ctx, reader, lifecycle, gateID, waiter)
if err != nil {
return HandleError("%v", err)
if issue.IssueType != "gate" {
return HandleError("%s is not a gate issue (type=%s)", gateID, issue.IssueType)
}
if !added {
renderGateWaiterAlready(gateID)
return nil
for _, w := range issue.Waiters {
if w == waiter {
renderGateWaiterAlready(gateID)
return nil
}
}
newWaiters := append(issue.Waiters, waiter)
updates := map[string]interface{}{
"waiters": newWaiters,
}
if err := store.UpdateIssue(ctx, gateID, updates, currentActor()); err != nil {
return HandleError("updating gate: %v", err)
}
commandDidWrite.Store(true)
@ -282,211 +288,6 @@ This is used by 'bd done --phase-complete' to register for gate wake notificatio
},
}
// addGateWaiter's compare-and-set budget. A version miss means another writer
// changed the gate between this command's read and its write; under a convoy
// (a phase finishing together, every worker registering on the same gate) each
// round of simultaneous writes has exactly one winner, so retrying at once
// would fail all but a handful of adders. Each retry therefore waits a
// jittered, doubling backoff first: gateAddWaiterBackoffBase, doubled per miss
// up to gateAddWaiterBackoffCap, each wait drawn uniformly from [d/2, d) so
// the losers of one round do not collide again in the next.
//
// The loop is bounded by gateAddWaiterMaxAttempts writes, not by wall time:
// one round's latency is the server's (a loaded remote server can take
// seconds per read and write), and a wall-clock budget would fail a convoy on
// a slow server after only two or three rounds. Each round has a winner, so
// the bound carries at least that many simultaneous adders; the jitter
// spreads them further. The backoffs themselves add up to at most about 6s,
// and a gate rewritten without pause still fails after the last attempt.
//
// A write lost to contention the store gave up replaying (see
// gateAddWaiterContended) is not one quick round, so it gets a much tighter
// bound of its own, gateAddWaiterContentionRetries. It reaches this loop only
// after the store or bd serve has spent a whole replay budget on it (up to
// 15s, the server-mode Dolt store's and bd serve's), and the wait after a
// busy answer includes the server's Retry-After (5s once bd serve's budget is
// spent). Two retries, like the HTTP client's for a busy read, hold that tail
// to three such writes (three 15s budgets and two 5s waits: about a minute),
// where twenty would take over six minutes. They count against
// gateAddWaiterMaxAttempts too.
const (
gateAddWaiterMaxAttempts = 20
gateAddWaiterContentionRetries = 2
gateAddWaiterBackoffBase = 10 * time.Millisecond
gateAddWaiterBackoffCap = 400 * time.Millisecond
)
// gateAddWaiterRetryWait is the wait before retry number retry after the
// failed write err: the jittered backoff, plus the server's Retry-After when
// err is a busy answer that carries one. bd serve sends Retry-After on its
// busy answers: 1s when its admission limiter is saturated, and 5s when its
// transaction retry budget is spent, because a convoy back sooner would hold
// slots while it waited, starving reads. It is honored as sent: the wire
// client already bounds the header (wire.Options.MaxRetryAfter). The jitter on
// top keeps adders that were answered busy together from retrying together.
func gateAddWaiterRetryWait(retry int, err error) time.Duration {
wait := gateAddWaiterBackoff(retry)
var problem *wire.ProblemError
if errors.Is(err, wire.ErrBusy) && errors.As(err, &problem) {
wait += problem.RetryAfter
}
return wait
}
// gateAddWaiterBackoff is the wait before retry number retry (1-based):
// jittered in [d/2, d) around d = base * 2^(retry-1), capped.
func gateAddWaiterBackoff(retry int) time.Duration {
d := gateAddWaiterBackoffBase
for i := 1; i < retry && d < gateAddWaiterBackoffCap; i++ {
d *= 2
}
if d > gateAddWaiterBackoffCap {
d = gateAddWaiterBackoffCap
}
half := d / 2
return half + time.Duration(rand.Int64N(int64(d-half))) // #nosec G404 -- retry jitter, not a secret
}
// gateAddWaiterSleep waits d or until ctx is done. It is a variable so tests
// can record the backoff without sleeping.
var gateAddWaiterSleep = func(ctx context.Context, d time.Duration) error {
timer := time.NewTimer(d)
defer timer.Stop()
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C:
return nil
}
}
// addGateWaiter registers waiter on the gate gateID through the Reader and
// Lifecycle roles, so every route (local, proxied server, and a connected HTTP
// workspace, which sends getIssue then updateIssue behind issues.update.gates)
// runs the same steps. It reports false, writing nothing, when the waiter is
// already registered.
//
// The write is a whole-value waiter list guarded by the row version the read
// returned, so two concurrent adders cannot lose each other's waiter: the
// second write misses its version, re-reads the list with the first waiter in
// it, and writes again. The deduplication is this command's, not the role's;
// the role stores the list it is given.
func addGateWaiter(ctx context.Context, reader issueops.Reader, lifecycle issueops.Lifecycle, gateID, waiter string) (bool, error) {
var lastErr error
attempts, contended := 0, 0
for attempts < gateAddWaiterMaxAttempts && contended <= gateAddWaiterContentionRetries {
if attempts > 0 {
if err := gateAddWaiterSleep(ctx, gateAddWaiterRetryWait(attempts, lastErr)); err != nil {
return false, fmt.Errorf("updating gate: %w", err)
}
}
attempts++
details, err := reader.Get(ctx, issueops.GetRequest{ID: gateID})
if errors.Is(err, storage.ErrNotFound) {
return false, fmt.Errorf("gate not found: %s", gateID)
}
if err != nil {
return false, fmt.Errorf("reading gate %s: %w", gateID, err)
}
gate := &details.Issue
if gate.IssueType != "gate" {
return false, fmt.Errorf("%s is not a gate issue (type=%s)", gateID, gate.IssueType)
}
if slices.Contains(gate.Waiters, waiter) {
return false, nil
}
waiters := append(slices.Clone(gate.Waiters), waiter)
version := gate.RowVersion
_, err = lifecycle.Update(ctx, issueops.UpdateRequest{
Actor: currentActor(),
IssueID: gate.ID,
Patch: issueops.IssuePatch{Waiters: issueops.Field[[]string]{Set: true, Value: waiters}},
ExpectedVersion: &version,
})
if err == nil {
return true, nil
}
if !gateAddWaiterLostRound(err) {
return false, fmt.Errorf("updating gate: %w", err)
}
if gateAddWaiterContended(err) {
contended++
}
lastErr = err
}
if errors.Is(lastErr, wire.ErrBusy) && gateAddWaiterLanded(ctx, reader, gateID, waiter) {
return false, nil
}
return false, gateAddWaiterExhausted(gateID, attempts, contended, lastErr)
}
// gateAddWaiterLanded reports whether waiter is on the gate gateID, read once
// after addGateWaiter's last write was answered busy. Such a write may have
// landed (see gateAddWaiterLostRound), and every earlier round's re-read
// would have found it, but the last write has no round left; so it gets this
// one read, with no wait first. A failed read reports false.
func gateAddWaiterLanded(ctx context.Context, reader issueops.Reader, gateID, waiter string) bool {
details, err := reader.Get(ctx, issueops.GetRequest{ID: gateID})
return err == nil && slices.Contains(details.Issue.Waiters, waiter)
}
// gateAddWaiterLostRound reports whether a failed guarded write is a lost
// round the loop retries: a version miss, or a write lost to contention the
// store gave up replaying (gateAddWaiterContended).
//
// Retrying is safe because of how a round is built, NOT because every busy
// answer means nothing was written. bd serve's own busy answers are no-write,
// but a gateway in front of the server can answer 503 after the write
// committed, and the client maps that uncoded 503 to wire.ErrBusy too. Each
// round re-reads the gate, deduplicates, and writes the whole list guarded by
// the row version it read, so a write that did land is found on the re-read
// (the waiter is already there: nothing more is written) and a stale list can
// never overwrite a newer one. So a retry never adds a waiter twice and never
// drops another adder's.
//
// Everything else is returned at once, including the classes a retry would
// also survive but that are not contention: a refusal, a database bd serve
// cannot reach (wire.ErrDBUnavailable), and a server fault such as an
// indeterminate commit (wire.ErrServerFault, a 500). Those are for the caller
// to see, not for a convoy loop to hammer.
func gateAddWaiterLostRound(err error) bool {
return errors.Is(err, issueops.ErrVersionMismatch) || gateAddWaiterContended(err)
}
// gateAddWaiterContended reports whether a failed guarded write was lost to
// contention the store gave up replaying. On the direct route that is a
// serialization failure or deadlock, which guarantees a rollback (Dolt and
// MySQL report 1213/1205, a SERIALIZABLE store such as Postgres SQLSTATE
// 40001/40P01): the store's transaction envelope replays one until its budget
// is spent and then returns it. Over HTTP it is wire.ErrBusy, which the client
// maps from bd serve's busy answer (a refused admission, or a spent retry
// budget) and from a 503 whose code it does not know or that has none, such as
// a gateway's. A 503 coded db_unavailable or events_watch_saturated maps to its
// own sentinel, not to this one.
//
// Dolt's 1105 "@autocommit transaction rolled back", which the direct route's
// store also replays, is deliberately not admitted: Dolt raises it for
// conflicts that a merge inside the transaction left behind, while a write
// lost to a concurrent writer, the convoy's case, comes back as 1213.
func gateAddWaiterContended(err error) bool {
return uow.IsSerializationError(err) || errors.Is(err, wire.ErrBusy)
}
// gateAddWaiterExhausted is addGateWaiter's error once it stops retrying:
// after attempts writes, contended of them answered busy or lost to
// contention, the last with lastErr. Only when none was contended did the gate
// change under every write, so only then does the error say that; otherwise it
// names the contention, so that the operator of a busy server is not sent
// looking for a concurrent writer. It says no write was confirmed, not that
// none landed, because a busy answer does not prove that nothing was written.
func gateAddWaiterExhausted(gateID string, attempts, contended int, lastErr error) error {
if contended == 0 {
return fmt.Errorf("updating gate: %s changed on every one of %d attempts: %w", gateID, attempts, lastErr)
}
return fmt.Errorf("updating gate: no write to %s was confirmed in %d attempts (%d answered busy or lost to write contention): %w", gateID, attempts, contended, lastErr)
}
// renderGateWaiterAlready and renderGateWaiterAdded are shared by the direct
// and proxied-server routes so `bd gate add-waiter` prints identically on both.
func renderGateWaiterAlready(gateID string) {
@ -525,6 +326,9 @@ Examples:
SilenceUsage: true,
SilenceErrors: true,
RunE: func(cmd *cobra.Command, args []string) error {
if usesProxiedServer() {
return runGateCreateProxiedServer(cmd, rootCtx)
}
CheckReadonly("gate create")
evt := metrics.NewCommandEvent("gate-create")
@ -539,25 +343,37 @@ Examples:
return HandleErrorRespectJSON("%v", err)
}
reader, err := openIssueReader()
ctx := rootCtx
targetIssue, err := store.GetIssue(ctx, in.blocksID)
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
lifecycle, err := openIssueLifecycle()
if err != nil {
return HandleErrorRespectJSON("%v", err)
}
ctx, err := issueOpsContext(rootCtx)
if err != nil {
return HandleErrorRespectJSON("%v", err)
return HandleErrorRespectJSON("issue not found: %s", in.blocksID)
}
gate, targetIssue, err := createGateThroughRoles(ctx, reader, lifecycle, in)
if err != nil {
return HandleErrorRespectJSON("%v", err)
gate := buildGateIssue(in, targetIssue.ID)
metadata, metaErr := gateMetadataForCreate(in, targetIssue)
if metaErr != nil {
return HandleErrorRespectJSON("%v", metaErr)
}
gate.Metadata = metadata
if err := store.CreateIssue(ctx, gate, currentActor()); err != nil {
return HandleErrorRespectJSON("creating gate: %v", err)
}
commandDidWrite.Store(true)
dep := &types.Dependency{
IssueID: targetIssue.ID,
DependsOnID: gate.ID,
Type: types.DepBlocks,
}
if err := store.AddDependency(ctx, dep, currentActor()); err != nil {
return HandleErrorRespectJSON("adding blocking dependency: %v", err)
}
commitMsg := fmt.Sprintf("bd: create gate %s blocking %s", gate.ID, targetIssue.ID)
if err := store.Commit(ctx, commitMsg); err != nil && !isDoltNothingToCommit(err) {
return HandleErrorRespectJSON("failed to commit: %v", err)
}
if jsonOutput {
return outputJSON(gate)
@ -568,48 +384,6 @@ Examples:
},
}
// createGateThroughRoles creates the gate and its blocking edge as ONE Lifecycle.Create:
// the gate row plus a reverse blocks dependency from the blocked issue to the
// new gate, in one transaction and one version commit on every route. A
// connected HTTP workspace sends it as one createIssue carrying the gate
// members, behind issues.create.gates; a server that does not advertise that
// token is refused before any request is sent, and nothing is written.
//
// It returns the created gate (without its dependency records, which
// `bd gate create` has never printed) and the blocked issue.
func createGateThroughRoles(ctx context.Context, reader issueops.Reader, lifecycle issueops.Lifecycle, in gateCreateInput) (*types.Issue, *types.Issue, error) {
details, err := reader.Get(ctx, issueops.GetRequest{ID: in.blocksID})
if err != nil {
// Every target-lookup failure has always been reported as not-found.
return nil, nil, fmt.Errorf("issue not found: %s", in.blocksID)
}
target := &details.Issue
gate := buildGateIssue(in, target.ID)
metadata, err := gateMetadataForCreate(in, target)
if err != nil {
return nil, nil, err
}
gate.Metadata = metadata
result, err := lifecycle.Create(ctx, issueops.CreateRequest{
Actor: currentActor(),
Issue: gate,
Dependencies: []issueops.CreateDependency{{
TargetID: target.ID,
Type: types.DepBlocks,
Reverse: true,
}},
})
if err != nil {
return nil, nil, fmt.Errorf("creating gate: %w", err)
}
created := result.Issue
created.Dependencies = nil
created.Comments = nil
return created, target, nil
}
// gateCreateInput carries `bd gate create`'s parsed flags. Both routes gather
// it through gatherGateCreateInput so they cannot drift on flag semantics.
type gateCreateInput struct {
@ -1614,9 +1388,9 @@ func beadGateNotFound(err error) bool {
// routedBeadGateGetter gives direct-mode gate checks the same local -> prefix
// route -> contributor fallback used by other read commands. Routed stores are
// opened read-only and closed before the result is returned. A route that
// fails or misses is reported as errBeadGateTargetUnconfirmed instead of as
// the local not-found.
// opened read-only and closed before the result is returned. Unlike
// getIssueWithRouting, a route that fails or misses is reported as
// errBeadGateTargetUnconfirmed instead of as the local not-found.
type routedBeadGateGetter struct {
localStore storage.DoltStorage
}

Some files were not shown because too many files have changed in this diff Show more