Struct TestDevice 

pub struct TestDevice { /* private fields */ }

Implementations

impl TestDevice

pub async fn query_test_text(&self, sql: &str) -> String

Replay this device’s retained history and count table’s rows.

The device performs the replay with the database it owns rather than handing that database out, so a caller checking a replay never gets a handle it could write through. Answer a read-only query against this device’s Store, for a test that never holds the database — a device installed by a join or a restore is opened by that install, not by its caller.

pub async fn test_row_exists(&self, sql: &str) -> bool

pub async fn latest_local_store_device_registration( &self, ) -> Result<Option<DurableDeviceRegistration>, DbError>

pub async fn replay_row_count_for_test( &self, table: &str, ) -> Result<i64, DbError>

pub fn device_id(&self) -> String

pub fn host_write_blob_staging(&self) -> HostWriteBlobStaging

pub async fn create( db: &Database, store_dir: StoreDir, storage: Arc<CloudSyncConnection>, founder_timestamp: &str, identity: UserKeypair, ) -> Result<Self, StoreInitializationError>

pub async fn create_with_database( database: StoreDatabase, store_dir: StoreDir, storage: Arc<CloudSyncConnection>, founder_timestamp: &str, identity: UserKeypair, ) -> Result<Self, StoreInitializationError>

pub async fn open_with_database( database: StoreDatabase, store_dir: StoreDir, storage: Arc<CloudSyncConnection>, root: &StoreRootRef, identity: &UserKeypair, ) -> Result<Self, StoreInitializationError>

pub async fn activate_joined( observer: Self, joining_database: StoreDatabase, joining_store_dir: StoreDir, joining_identity: &UserKeypair, published_at: &str, storage: Arc<CloudSyncConnection>, ) -> Result<Self, TestError>

pub async fn latest_local_store_snapshot_for_test( &self, ) -> Result<Option<PublishedStoreSnapshot>, TestError>

pub async fn publish_snapshot_generation_for_test( &self, ) -> Result<PublishedStoreSnapshot, TestError>

Publish one more generation over the current frontier and acknowledge it, the way the cadence would.

pub async fn ensure_device_join_snapshot_for_test( &self, ) -> Result<(), TestError>

pub async fn load( db: &Database, store_dir: StoreDir, storage: Arc<CloudSyncConnection>, identity: UserKeypair, ) -> Result<Self, StoreError>

pub async fn load_with_database( database: StoreDatabase, storage: Arc<CloudSyncConnection>, identity: UserKeypair, store_dir: StoreDir, ) -> Result<Self, StoreError>

pub fn adopt_key_rotation( &self, encryption: &EncryptionService, custody: &dyn MasterKeyCustody, ) -> Result<String, KeyError>

pub fn store_root(&self) -> &StoreRootRef

pub async fn authorize_writer( &self, ) -> Result<AuthorizedWriterOperation<'_>, StoreError>

pub async fn execute_unscoped_host_sql_for_test( &self, sql: String, ) -> Result<(), HostWriteError<DbError>>

pub async fn membership_for_test(&self) -> Result<MembershipChain, StoreError>

pub async fn latest_local_store_position( &self, ) -> Result<Option<StoreBatchCommitRef>, StoreError>

pub async fn load_commit_for_test( &self, reference: &StoreBatchCommitRef, ) -> Result<VerifiedStoreBatchCommit, StoreError>

pub async fn load_membership_head_for_test( &self, reference: &MembershipHeadRef, ) -> Result<AuthorHead, StoreError>

pub async fn load_exact_materialized_commit( &self, stream_id: &str, sequence: u64, ) -> Result<Option<(StoreBatchCommitRef, VerifiedStoreBatchCommit)>, StoreError>

pub fn device_join_transport(&self) -> StoreDeviceJoinTransport<'_>

pub fn circles(&self) -> StoreCircleCommands<'_>

pub async fn circle_epoch_access( &self, circle_id: CircleId, expected_control: CircleControlCoord, ) -> Result<Option<CircleEpochAccess>, DbError>

pub async fn discard_blocked_write( &self, write_id: WriteId, ) -> Result<Vec<WriteId>, StoreError>

pub async fn restore_membership( &self, ) -> Result<StoreRestoreMembership, MembershipOpsError>

pub async fn owner_recovery_for_test( &self, ) -> Result<RestoringStore<'_>, TestError>

pub async fn begin_device_join( &self, member_pubkey: &str, ) -> Result<DeviceJoinOffer, DeviceJoinError>

pub async fn begin_owner_promotion_for_device( &self, device_id: StoreDeviceId, ) -> Result<OwnerPromotionRequest, OwnerPromotionError>

pub async fn begin_owner_promotion( &self, member_registration: StoreDeviceRegistrationRef, ) -> Result<OwnerPromotionRequest, OwnerPromotionError>

pub async fn accept_owner_promotion( &self, request: OwnerPromotionRequest, ) -> Result<OwnerPromotionAcceptance, OwnerPromotionError>

pub async fn finalize_owner_promotion( &self, encryption: &EncryptionService, acceptance: OwnerPromotionAcceptance, ) -> Result<StoreMembershipStateRef, OwnerPromotionError>

pub async fn blob_key_fingerprint_for_test( &self, authority: &RowBlobAuthority, stored: &StoredBlobRef, ) -> Result<Option<KeyFingerprint>, TestError>

pub async fn announcement_stream_id_for_test( &self, ) -> Result<AuthorStreamId, StoreError>

pub async fn sign_device_head_for_test( &self, commit: StoreBatchCommitRef, successor: SuccessorLink, ) -> Result<StoreDeviceHead, StoreError>

pub async fn owner_promotion_target_for_test( &self, ) -> Result<StoreDeviceRegistrationRef, StoreError>

pub async fn observe_excluded_candidate_head_for_test( &self, candidate: &StoreDeviceHead, candidate_commit: &StoreBatchCommit, candidate_object: &ExactObjectRef, ) -> Result<ExcludedCandidateHeadObservation, StoreError>

pub async fn cleanup_merge_candidate_for_test( &self, write_id: WriteId, ) -> Result<(), StoreError>

pub async fn resign_snapshot_meta_for_test( &self, meta: SnapshotMeta, ) -> Result<SnapshotMeta, StoreError>

pub async fn parse_local_snapshot_meta_for_test( &self, bytes: &[u8], reference: &StoreSnapshotRef, ) -> Result<SnapshotMeta, StoreError>

pub async fn prepare_operation_plan_for_test( &self, ) -> Result<StoreOperationCommitPlan, StoreError>

pub async fn authorize_retained_outbound_for_test( &self, order: &StoreCommitOrder, candidate_membership_heads: &[MembershipHeadRef], ) -> Result<MergeOutboundAuthorization, StoreError>

pub async fn complete_revoke_rotation_adoption_for_test( &self, pending_rotation: &dyn CloudSyncRotationStateAccess, adopted_generation: u64, ) -> Result<(), MembershipMutationError>

pub async fn retained_merge_replay_inputs_for_test( &self, ) -> Result<Vec<OwnedVerifiedMergeMaterialization>, DbError>

pub async fn resolved_store_device_state_for_test( &self, reference: &StoreDeviceStateRef, ) -> Result<ResolvedStoreDeviceState, DbError>

pub async fn retained_merge_materialization_for_test( &self, reference: StoreBatchCommitRef, ) -> Result<OwnedVerifiedMergeMaterialization, DbError>

pub async fn prepare_conflict_resolution_plan_for_test( &self, candidate_membership_heads: &[MembershipHeadRef], ) -> Result<(), StoreError>

pub async fn load_membership_at_exact_heads_for_test( &self, heads: &[MembershipHeadRef], resolutions: &[StoreMembershipConflictResolutionRef], ) -> Result<MembershipChain, StoreError>

pub async fn project_membership_for_test( &self, candidate_heads: &[MembershipHeadRef], ) -> Result<MembershipChain, StoreError>

pub async fn assert_deep_membership_projection_for_test( &self, heads: &[MembershipHeadRef], ) -> Result<(), StoreError>

pub async fn exact_next_announcement_slot_for_test( &self, registration_ref: &StoreDeviceRegistrationRef, registration: &StoreDeviceRegistration, previous: Option<&StoreBatchCommitRef>, ) -> Result<(ObjectSlot, Option<StoreDeviceHeadRef>), StoreError>

pub async fn load_registration_for_test( &self, reference: &StoreDeviceRegistrationRef, ) -> Result<StoreDeviceRegistration, StoreError>

pub async fn verify_installable_snapshots_for_test( &self, snapshots: &[PublishedStoreSnapshot], ) -> Result<(), StoreError>

pub async fn open_circle_package_for_test( &self, access: &CircleEpochAccess, commit: &VerifiedStoreBatchCommit, reference: &CirclePackageRef, ) -> Result<Vec<u8>, StoreError>

pub async fn pull_readiness_for_test( &self, coverage: &CommitFrontier, frontier: &BTreeMap<String, StoreBatchCommitRef>, device_state: &ResolvedStoreDeviceState, exclusion_freezes: &[StoreDeviceProposalAck], commit_ref: &StoreBatchCommitRef, commit: &StoreBatchCommit, ) -> Result<Readiness, StorePullError>

pub async fn verified_merge_membership_prefix_for_test( &self, references: impl IntoIterator<Item = StoreBatchCommitRef>, predecessors: impl IntoIterator<Item = StoreBatchCommitRef>, ) -> Result<VerifiedMergeMembershipPrefix, StorePullError>

pub async fn retained_merge_history_frontier_for_test( &self, references: Vec<StoreBatchCommitRef>, ) -> Result<Vec<RetainedMergeHistoryCheckpoint>, DbError>

pub async fn verified_circle_activation_for_test( &self, circle_id: CircleId, control: CircleControlCoord, ) -> Result<Option<VerifiedCircleReference>, DbError>

pub async fn finalized_circle_close_outcome_for_test( &self, circle_id: CircleId, ) -> Result<CircleEpochCloseOutcome, CircleOperationError>

pub async fn circle_package_is_retained_for_replay_for_test( &self, target: CirclePackageRef, activation: StoreBatchCommitRef, ) -> Result<bool, DbError>

pub async fn load_circle_acknowledgement_for_test( &self, reference: &CircleAckRef, ) -> Result<CircleAck, StoreAckError>

pub async fn load_applicable_circle_packages_for_test( &self, verified: &VerifiedStoreBatchCommit, activations: &[VerifiedCircleReference], author: &StoreDeviceRegistration, local_store_membership: LocalStoreMembership, ) -> Result<Vec<LoadedCirclePackage>, CirclePackageReadError>

pub fn protocol_root_for_test(&self) -> &StoreProtocolRoot

pub async fn prepare_acknowledgement_activation_for_test( &self, acknowledgement: StoreAckRef, candidate: PreparedStoreOperationCommit, ) -> Result<(), DbError>

pub async fn prepare_merge_history_successor_for_test( &self, verified_commit: &VerifiedStoreBatchCommit, recovery_author: Option<&StoreDeviceRegistrationRef>, evidence: MergeHistorySuccessorEvidence, ) -> Result<PreparedMergeHistorySuccessor, StoreError>

pub async fn prepare_device_join_bootstrap_for_test( &self, bootstrap_cut: &StoreHistoryCut, attempt_activation: &StoreBatchCommitRef, membership_state: &StoreMembershipStateRef, installed: &CommitFrontier, ) -> Result<DeviceJoinBootstrapPlan, StoreError>

pub async fn load_store_package_for_test( &self, reference: &StoreBatchCommitRef, ) -> Result<Option<VerifiedObject<Vec<u8>>>, StoreError>

pub async fn load_store_ack_for_test( &self, reference: &StoreAckRef, registration: &StoreDeviceRegistration, ) -> Result<StoreAck, StoreError>

pub async fn load_head_for_test( &self, reference: &StoreDeviceHeadRef, registration: &StoreDeviceRegistration, commit: &StoreBatchCommitRef, ) -> Result<StoreDeviceHead, StoreError>

pub async fn remove_member( &self, public_key_hex: &str, encryption: &EncryptionService, master_keys: &dyn MasterKeyCustody, cipher: &dyn CloudSyncCipherStateAccess, pending_rotation: &dyn CloudSyncRotationStateAccess, ) -> Result<String, MembershipOpsError>

pub async fn authorize_device_provider_access( &self, request: DeviceProviderAccessRequest, access_administrator: Option<&dyn DeviceProviderAccessAdministrator>, ) -> Result<DeviceProviderAdmissionApproval, DeviceJoinError>

pub async fn publish_device_provider_challenge( &self, bootstrap: ProvisionalDeviceBootstrap, ) -> Result<ProviderReadyDeviceBootstrap, DeviceJoinError>

pub async fn complete_device_provider_admission( &self, readiness: DeviceJoinReadiness, ) -> Result<DeviceProviderAdmissionCompletion, DeviceJoinError>

pub async fn abandon_device_join( &self, offer: DeviceJoinOffer, ) -> Result<DeviceJoinAbandonment, DeviceJoinError>

pub async fn accept_device_registration_request( &self, request: DeviceRegistrationRequest, ) -> Result<ProvisionalDeviceBootstrap, DeviceJoinError>

pub async fn activate_same_principal_join_for_test( &self, request: DeviceRegistrationRequest, ) -> Result<SamePrincipalDeviceJoin, DeviceJoinError>

pub async fn finalize_device_join( &self, completion: DeviceProviderAdmissionCompletion, ) -> Result<DeviceJoinActivation, DeviceJoinError>

pub async fn device_exclusion_operations_for_test( &self, ) -> Result<Vec<StoreDeviceExclusionOperationInfo>, StoreDeviceExclusionError>

pub async fn stage_uploaded_device_exclusion_proposal_for_test( &self, ) -> Result<StoreDeviceExclusionProposalRef, StoreDeviceExclusionError>

pub async fn propose_device_exclusion( &self, target: &StoreDeviceRegistrationRef, ) -> Result<StoreDeviceExclusionResult, StoreDeviceExclusionError>

pub async fn cancel_device_exclusion( &self, proposal: &StoreDeviceExclusionProposalRef, ) -> Result<StoreDeviceExclusionResult, StoreDeviceExclusionError>

pub async fn finalize_device_exclusion( &self, proposal: &StoreDeviceExclusionProposalRef, ) -> Result<StoreDeviceExclusionResult, StoreDeviceExclusionError>

pub async fn pending_device_join_observation_for_test( &self, pending: &DeviceJoinJournalDatabase, offer: &DeviceJoinOffer, ) -> Result<PendingDeviceJoinObservation<'_>, TestError>

pub async fn open_pending_device_join_for_test( &self, pending: &DeviceJoinJournalDatabase, identity: &UserKeypair, offer: DeviceJoinOffer, ) -> Result<PendingDeviceJoinAuthority<'_>, TestError>

pub async fn prepare_snapshot_bootstrap_for_test( &self, membership_floor: &MembershipFloor, binary_schema_version: u32, target_path: &Path, restorer_identity: &UserKeypair, ) -> Result<PreparedSnapshotBootstrap<'_>, SnapshotError>

pub async fn admit_member( &self, member_pubkey: &str, member_email: Option<&str>, role: MemberRole, encryption: &EncryptionService, store_id: &str, store_name: &str, ) -> Result<MemberAdmission, MembershipOpsError>

pub async fn drain_uploads( &self, clock: &dyn Clock, routing_encryption: Option<&EncryptionService>, observer: Option<&dyn BlobTransitionObserver>, ) -> Result<DrainOutcome, TestError>

pub async fn publish_pending_store_database(&self) -> Result<bool, TestError>

pub async fn publish_fixture_position(&self, note_id: &str) -> u64

pub async fn publish_exact_remote_blob_binding( &self, root_id: &str, row_id: &str, bytes: &[u8], ) -> StoredBlobRef

pub async fn activated_store_device_registration_for_test( &self, reference: StoreDeviceRegistrationRef, ) -> Result<ReferencedStoreDeviceRegistration, DbError>

pub fn schema_version(&self) -> u32

pub async fn device_authority_for_test( &self, ) -> Result<TestDeviceSigningAuthority, TestError>

pub async fn publish_changeset_for_test( &self, sequence: u64, changeset: Vec<u8>, schema_version: u32, ) -> Result<StoreBatchCommitRef, TestError>

pub async fn publish_changeset_after_for_test( &self, changeset: Vec<u8>, previous_sequence: u64, ) -> Result<StoreBatchCommitRef, TestError>

pub async fn create_exact_opaque_blob( &self, namespace: &str, id: &str, bytes: &[u8], ) -> StoredBlobRef

pub async fn create_exact_browsable_blob( &self, namespace: &str, id: &str, cloud_path: &str, bytes: &[u8], ) -> StoredBlobRef

pub async fn run_cycle( &self, observer: Option<&dyn BlobTransitionObserver>, ) -> Result<SyncCycleResult, SyncCycleFailure>

pub async fn run_cycle_with( &self, clock: &dyn Clock, master_keys: Option<Arc<dyn MasterKeyCustody>>, observer: Option<&dyn BlobTransitionObserver>, ) -> Result<SyncCycleResult, SyncCycleFailure>

pub async fn run_cycle_with_interceptor<I>( &self, clock: &dyn Clock, master_keys: Option<Arc<dyn MasterKeyCustody>>, observer: Option<&dyn BlobTransitionObserver>, interceptor: I, ) -> Result<SyncCycleResult, SyncCycleFailure>

where I: StorageInterceptor + 'static,

pub fn current_keyring_for_test(&self) -> Option<CloudKeyringFacts>

pub fn mark_rotation_committed_for_test( &self, generation: u64, ) -> Result<(), RotationStateError>

pub fn pending_rotation_generation_for_test(&self) -> Option<u64>

pub fn clear_rotation_gate_for_test(&self)

pub async fn create_circle( &self, metadata_stamp: &str, name: &str, ) -> Result<CircleId, CircleOperationError>

pub async fn publish_circle_epoch_close_response( &self, ) -> Result<(), CircleOperationError>

pub async fn publish_circle_operation( &self, operation_id: &CircleOperationId, ) -> Result<(), CircleOperationError>

pub async fn resume_circle_operations(&self) -> Result<(), CircleOperationError>

pub async fn retry_circle_operation( &self, operation_id: &CircleOperationId, ) -> Result<(), CircleOperationError>

pub async fn prepare_pending_store_write(&self) -> Result<bool, StoreError>

pub async fn drain_store_writes(&self) -> Result<u64, StoreError>

pub async fn reclaim_packages( &self, ) -> Result<StoreReclaimResult, StoreReclaimError>

pub async fn abandon_merge_candidate( &self, write_id: WriteId, ) -> Result<MergeCandidateAbandonment, StoreError>

pub async fn prepare_merge_candidate_abandonment( &self, write_id: WriteId, ) -> Result<bool, StoreError>

pub async fn prepare_peer_exclusion( &self, target: &StoreDeviceRegistrationRef, ) -> StoreDeviceExclusionProposalRef

pub async fn activate_peer_exclusion( &self, proposal: &StoreDeviceExclusionProposalRef, ) -> StoreDeviceExclusionRef

pub async fn finalize_peer_exclusion( &self, target: &StoreDeviceRegistrationRef, ) -> StoreDeviceExclusionRef

pub async fn prepare_circle_object( &self, context: &ProtocolObjectContext, semantic_prefix: &str, extension: &str, bytes: Vec<u8>, ) -> Result<PreparedExactObject, CircleOperationError>

pub async fn prepare_circle_object_at( &self, context: &ProtocolObjectContext, slot: ObjectSlot, semantic_prefix: &str, bytes: Vec<u8>, ) -> Result<PreparedExactObject, CircleOperationError>

pub async fn prepare_circle_activation_objects( &self, draft: CircleTransitionDraft, history: &CircleTransitionHistory, candidate_family: CandidateFamilyId, ) -> Result<(PreparedCircleTransition, CircleActivationObjects, BTreeMap<String, PreparedExactObject>, Option<ExactObjectRef>, Vec<StreamActivation>), CircleOperationError>

pub async fn sign_circle_commit( &self, old_commit: &StoreBatchCommit, coord: StoreCommitCoord, reference: CircleControlRef, stream_activations: Vec<StreamActivation>, ) -> Result<StoreBatchCommit, CircleOperationError>

pub async fn rename_circle( &self, metadata_stamp: &str, circle_id: CircleId, name: &str, ) -> Result<(), CircleOperationError>

pub async fn delete_circle( &self, circle_id: CircleId, ) -> Result<(), CircleOperationError>

pub async fn load_circle_activations( &self, commit_ref: &StoreBatchCommitRef, commit: &StoreBatchCommit, author: &StoreDeviceRegistration, ) -> Result<VerifiedCircleActivations, CircleOperationError>

pub async fn circle_blob_opening_error( &self, authority: &RowBlobAuthority, stored: &StoredBlobRef, ) -> StoreError

pub async fn load_circle_snapshot_refs( &self, circle_id: CircleId, access: &CircleEpochAccess, ) -> Result<Vec<(CircleSnapshotRef, CircleSnapshotMeta)>, TestError>

pub async fn membership(&self) -> Result<MembershipChain, TestError>

pub fn protocol_root(&self) -> &StoreProtocolRoot

pub async fn publish_snapshot( &self, db_image: Vec<u8>, coverage: CommitFrontier, ) -> Result<SnapshotMeta, TestError>

pub async fn publish_snapshot_at( &self, db_image: Vec<u8>, coverage: CommitFrontier, created_at: &str, ) -> Result<SnapshotMeta, SnapshotError>

pub async fn resume_snapshot_publication( &self, ) -> Result<Option<SnapshotMeta>, SnapshotError>

pub async fn publish_acknowledgement( &self, frontier: CommitFrontier, ) -> Result<Option<AdvancedReplayBaseline>, TestError>

Publish an acknowledgement, then run the independent replay baseline stage and report what it retired.

pub async fn stage_acknowledgement( &self, frontier: CommitFrontier, sync_time: String, ) -> Result<Option<StoreAck>, TestError>

pub async fn publish_acknowledgement_without_advancing( &self, frontier: CommitFrontier, ) -> Result<(), TestError>

Publish the statement and leave baseline retirement to its own cycle stage.

pub async fn stand_on_acknowledged_snapshot( &self, ) -> Result<ReplayBaselineAdvance, TestError>

Stand on the snapshot this device has acknowledged, the way the cycle does, and report what it did or why it did nothing.

pub async fn advance_baseline_by_acknowledging( &self, frontier: CommitFrontier, ) -> Result<Option<AdvancedReplayBaseline>, TestError>

Publish an acknowledgement and run the baseline stage that follows it in a cycle.

pub async fn materialized_frontier( &self, ) -> Result<BTreeMap<String, StoreBatchCommitRef>, TestError>

pub async fn drain_acknowledgements(&self) -> Result<u64, TestError>

pub fn typed_device_id(&self) -> StoreDeviceId

pub async fn load_commit_ancestry_until( &self, start: StoreBatchCommitRef, coverage: &CommitFrontier, ) -> Result<Vec<(StoreBatchCommitRef, VerifiedStoreBatchCommit)>, TestError>

pub async fn export_activated_device_continuation( &self, ) -> Result<ActivatedContinuation, TestError>

pub async fn latest_store_position( &self, ) -> Result<Option<StoreBatchCommitRef>, TestError>

pub async fn pull_store( &self, ) -> Result<(BTreeMap<String, u64>, StorePullResult), TestPullError>

pub async fn pull_store_and_fill_eager( &self, ) -> Result<(BTreeMap<String, u64>, StorePullResult), TestPullError>

Pull, then run the eager cache fill the sync loop runs behind its cycles. A pull records what its rows bind and downloads none of it, so this is what makes an eager blob’s bytes local.

pub async fn pull_store_with_encryption( &self, routing_encryption: &EncryptionService, ) -> Result<(BTreeMap<String, u64>, StorePullResult), TestPullError>

Trait Implementations

impl Clone for TestDevice

fn clone(&self) -> TestDevice

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.