Struct holochain::conductor::handle::MockConductorHandleT

pub struct MockConductorHandleT { /* private fields */ }

Base trait for ConductorHandle

Implementations

impl MockConductorHandleT

pub fn checkpoint(&mut self)

Validate that all current expectations for all methods have been satisfied, and discard them.

pub fn new() -> Self

Create a new mock object with no expectations.

This method will not be generated if the real struct already has a new method. However, it will be generated if the struct implements a trait with a new method. The trait’s new method can still be called like <MockX as TraitY>::new

impl MockConductorHandleT

pub fn expect_check_running(&mut self) -> &mut Expectation

Create an Expectation for mocking the check_running method

pub fn expect_initialize_conductor(&mut self) -> &mut Expectation

Create an Expectation for mocking the initialize_conductor method

pub fn expect_add_admin_interfaces(&mut self) -> &mut Expectation

Create an Expectation for mocking the add_admin_interfaces method

pub fn expect_add_app_interface(&mut self) -> &mut Expectation

Create an Expectation for mocking the add_app_interface method

pub fn expect_list_app_interfaces(&mut self) -> &mut Expectation

Create an Expectation for mocking the list_app_interfaces method

pub fn expect_register_dna(&mut self) -> &mut Expectation

Create an Expectation for mocking the register_dna method

pub fn expect_hot_swap_coordinators(&mut self) -> &mut Expectation

Create an Expectation for mocking the hot_swap_coordinators method

pub fn expect_list_dnas(&mut self) -> &mut Expectation

Create an Expectation for mocking the list_dnas method

pub fn expect_get_dna_def(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_dna_def method

pub fn expect_get_dna_file(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_dna_file method

pub fn expect_get_ribosome(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_ribosome method

pub fn expect_get_entry_def(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_entry_def method

pub fn expect_load_dnas(&mut self) -> &mut Expectation

Create an Expectation for mocking the load_dnas method

pub fn expect_dispatch_holochain_p2p_event(&mut self) -> &mut Expectation

Create an Expectation for mocking the dispatch_holochain_p2p_event method

pub fn expect_call_zome(&mut self) -> &mut Expectation

Create an Expectation for mocking the call_zome method

pub fn expect_call_zome_with_workspace(&mut self) -> &mut Expectation

Create an Expectation for mocking the call_zome_with_workspace method

pub fn expect_get_arbitrary_admin_websocket_port(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_arbitrary_admin_websocket_port method

pub fn expect_get_queue_consumer_workflows(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_queue_consumer_workflows method

pub fn expect_get_config(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_config method

pub fn expect_take_shutdown_handle(&mut self) -> &mut Expectation

Create an Expectation for mocking the take_shutdown_handle method

pub fn expect_shutdown(&mut self) -> &mut Expectation

Create an Expectation for mocking the shutdown method

pub fn expect_keystore(&mut self) -> &mut Expectation

Create an Expectation for mocking the keystore method

pub fn expect_holochain_p2p(&mut self) -> &mut Expectation

Create an Expectation for mocking the holochain_p2p method

pub fn expect_prune_p2p_agents_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the prune_p2p_agents_db method

pub fn expect_create_clone_cell(&mut self) -> &mut Expectation

Create an Expectation for mocking the create_clone_cell method

pub fn expect_destroy_clone_cell(&mut self) -> &mut Expectation

Create an Expectation for mocking the destroy_clone_cell method

pub fn expect_install_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the install_app method

pub fn expect_install_app_bundle(&mut self) -> &mut Expectation

Create an Expectation for mocking the install_app_bundle method

pub fn expect_uninstall_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the uninstall_app method

pub fn expect_reconcile_app_status_with_cell_status(
    &mut self
) -> &mut Expectation

Create an Expectation for mocking the reconcile_app_status_with_cell_status method

pub fn expect_reconcile_cell_status_with_app_status(
    &mut self
) -> &mut Expectation

Create an Expectation for mocking the reconcile_cell_status_with_app_status method

pub fn expect_enable_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the enable_app method

pub fn expect_disable_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the disable_app method

pub fn expect_start_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the start_app method

pub fn expect_start_scheduler(&mut self) -> &mut Expectation

Create an Expectation for mocking the start_scheduler method

pub fn expect_dispatch_scheduled_fns(&mut self) -> &mut Expectation

Create an Expectation for mocking the dispatch_scheduled_fns method

pub fn expect_post_commit_permit(&mut self) -> &mut Expectation

Create an Expectation for mocking the post_commit_permit method

pub fn expect_pause_app(&mut self) -> &mut Expectation

Create an Expectation for mocking the pause_app method

pub fn expect_list_cell_ids(&mut self) -> &mut Expectation

Create an Expectation for mocking the list_cell_ids method

pub fn expect_list_running_apps(&mut self) -> &mut Expectation

Create an Expectation for mocking the list_running_apps method

pub fn expect_list_apps(&mut self) -> &mut Expectation

Create an Expectation for mocking the list_apps method

pub fn expect_list_running_apps_for_required_cell_id(
    &mut self
) -> &mut Expectation

Create an Expectation for mocking the list_running_apps_for_required_cell_id method

pub fn expect_list_running_apps_for_required_dna_hash(
    &mut self
) -> &mut Expectation

Create an Expectation for mocking the list_running_apps_for_required_dna_hash method

pub fn expect_dump_cell_state(&mut self) -> &mut Expectation

Create an Expectation for mocking the dump_cell_state method

pub fn expect_dump_full_cell_state(&mut self) -> &mut Expectation

Create an Expectation for mocking the dump_full_cell_state method

pub fn expect_dump_network_metrics(&mut self) -> &mut Expectation

Create an Expectation for mocking the dump_network_metrics method

pub fn expect_signal_broadcaster(&mut self) -> &mut Expectation

Create an Expectation for mocking the signal_broadcaster method

pub fn expect_get_app_info(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_app_info method

pub fn expect_add_agent_infos(&mut self) -> &mut Expectation

Create an Expectation for mocking the add_agent_infos method

pub fn expect_get_agent_infos(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_agent_infos method

pub fn expect_print_setup(&mut self) -> &mut Expectation

Create an Expectation for mocking the print_setup method

pub fn expect_remove_cells(&mut self) -> &mut Expectation

Create an Expectation for mocking the remove_cells method

pub fn expect_insert_records_into_source_chain(&mut self) -> &mut Expectation

Create an Expectation for mocking the insert_records_into_source_chain method

pub fn expect_get_authored_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_authored_db method

pub fn expect_get_dht_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_dht_db method

pub fn expect_get_dht_db_cache(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_dht_db_cache method

pub fn expect_get_cache_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_cache_db method

pub fn expect_get_p2p_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_p2p_db method

pub fn expect_get_p2p_metrics_db(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_p2p_metrics_db method

pub fn expect_get_spaces(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_spaces method

pub fn expect_get_cell_triggers(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_cell_triggers method

pub fn expect_get_state_from_handle(&mut self) -> &mut Expectation

Create an Expectation for mocking the get_state_from_handle method

pub fn expect_add_test_app_interface(&mut self) -> &mut Expectation

Create an Expectation for mocking the add_test_app_interface method

pub fn expect_dev_settings(&mut self) -> &mut Expectation

Create an Expectation for mocking the dev_settings method

pub fn expect_update_dev_settings(&mut self) -> &mut Expectation

Create an Expectation for mocking the update_dev_settings method

pub fn expect_update_cell_status(&mut self) -> &mut Expectation

Create an Expectation for mocking the update_cell_status method

pub fn expect_transition_app_status(&mut self) -> &mut Expectation

Create an Expectation for mocking the transition_app_status method

Trait Implementations

impl ConductorHandleT for MockConductorHandleT

Base trait for ConductorHandle

fn check_running(&self) -> ConductorResult<()>

Returns error if conductor is shutting down

fn initialize_conductor<'async_trait>(
    self: Arc<Self>,
    admin_configs: Vec<AdminInterfaceConfig>
) -> Pin<Box<dyn Future<Output = ConductorResult<CellStartupErrors>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Initialize the task manager, add admin interfaces from config, start up app interfaces from db, and register all tasks.

This requires a concrete ConductorHandle to be passed into the interface tasks. This is a bit weird to do, but it was the only way around having a circular reference in the types.

Never use a ConductorHandle for different Conductor here!

fn add_admin_interfaces<'async_trait>(
    self: Arc<Self>,
    configs: Vec<AdminInterfaceConfig>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Add a collection of admin interfaces from config

fn add_app_interface<'async_trait>(
    self: Arc<Self>,
    port: u16
) -> Pin<Box<dyn Future<Output = ConductorResult<u16>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Add an app interface

fn list_app_interfaces<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<u16>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

List the app interfaces currently install.

fn register_dna<'life0, 'async_trait>(
    &'life0 self,
    dna: DnaFile
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Install a DnaFile in this Conductor

fn hot_swap_coordinators<'life0, 'life1, 'async_trait>(
    &'life0 self,
    hash: &'life1 DnaHash,
    coordinator_zomes: CoordinatorZomes,
    wasms: Vec<DnaWasm>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Hot swap coordinator zomes on an existing dna.

fn list_dnas(&self) -> Vec<DnaHash>

Get the list of hashes of installed Dnas in this Conductor

fn get_dna_def(&self, hash: &DnaHash) -> Option<DnaDef>

Get a DnaDef from the RibosomeStore

fn get_dna_file(&self, hash: &DnaHash) -> Option<DnaFile>

Get a DnaFile from the RibosomeStore

fn get_ribosome(&self, dna_hash: &DnaHash) -> ConductorResult<RealRibosome>

Get an instance of a RealRibosome for the DnaHash

fn get_entry_def(&self, key: &EntryDefBufferKey) -> Option<EntryDef>

Get an EntryDef from the EntryDefBufferKey

fn load_dnas<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Add the DnaFiles from the wasm and dna_def databases into memory

fn dispatch_holochain_p2p_event<'life0, 'async_trait>(
    &'life0 self,
    event: HolochainP2pEvent
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Dispatch a network event to the correct cell. Warning: returning an error from this function kills the network for the conductor.

fn call_zome<'life0, 'async_trait>(
    &'life0 self,
    invocation: ZomeCall
) -> Pin<Box<dyn Future<Output = ConductorApiResult<ZomeCallResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Invoke a zome function on a Cell

fn call_zome_with_workspace<'life0, 'async_trait>(
    &'life0 self,
    invocation: ZomeCall,
    workspace_lock: SourceChainWorkspace
) -> Pin<Box<dyn Future<Output = ConductorApiResult<ZomeCallResult>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Invoke a zome function on a Cell with a workspace

fn get_arbitrary_admin_websocket_port(&self) -> Option<u16>

Get a Websocket port which will

fn get_queue_consumer_workflows(&self) -> QueueConsumerMap

Get the running queue consumer workflows per DnaHash map.

fn get_config(&self) -> &ConductorConfig

Get the conductor config

fn take_shutdown_handle(&self) -> Option<JoinHandle<TaskManagerResult>>

Return the JoinHandle for all managed tasks, which when resolved will signal that the Conductor has completely shut down.

NB: The JoinHandle is not cloneable, so this can only ever be called successfully once.

fn shutdown(&self)

Send a signal to all managed tasks asking them to end ASAP.

fn keystore(&self) -> &MetaLairClient

Request access to this conductor’s keystore

fn holochain_p2p(&self) -> &HolochainP2pRef

Request access to this conductor’s networking handle

fn prune_p2p_agents_db<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Prune expired agent_infos from the p2p agents database

fn create_clone_cell<'async_trait>(
    self: Arc<Self>,
    payload: CreateCloneCellPayload
) -> Pin<Box<dyn Future<Output = ConductorResult<CellId>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Create a new Cell in an existing App based on an existing DNA

fn destroy_clone_cell<'async_trait>(
    self: Arc<Self>,
    cell_id: CellId
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Destroy a cloned Cell

fn install_app<'async_trait>(
    self: Arc<Self>,
    installed_app_id: InstalledAppId,
    cell_data_with_proofs: Vec<(InstalledCell, Option<MembraneProof>)>
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Install Cells into ConductorState based on installation info, and run genesis on all new source chains

fn install_app_bundle<'async_trait>(
    self: Arc<Self>,
    payload: InstallAppBundlePayload
) -> Pin<Box<dyn Future<Output = ConductorResult<StoppedApp>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Install DNAs and set up Cells as specified by an AppBundle

fn uninstall_app<'life0, 'async_trait>(
    self: Arc<Self>,
    app: &'life0 InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Uninstall an app from the state DB and remove all running Cells

fn reconcile_app_status_with_cell_status<'life0, 'async_trait>(
    &'life0 self,
    app_ids: Option<HashSet<InstalledAppId>>
) -> Pin<Box<dyn Future<Output = ConductorResult<AppStatusFx>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Adjust app statuses (via state transitions) to match the current reality of which Cells are present in the conductor.

fn reconcile_cell_status_with_app_status<'async_trait>(
    self: Arc<Self>
) -> Pin<Box<dyn Future<Output = ConductorResult<CellStartupErrors>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Adjust which cells are present in the Conductor (adding and removing as needed) to match the current reality of all app statuses.

• If a Cell is used by at least one Running app, then ensure it is added
• If a Cell is used by no running apps, then ensure it is removed.

fn enable_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<(InstalledApp, CellStartupErrors)>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Activate an app

fn disable_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId,
    reason: DisabledAppReason
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Disable an app

fn start_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Start an enabled but stopped (paused) app

fn start_scheduler<'async_trait>(
    self: Arc<Self>,
    interval_period: Duration
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    Self: 'async_trait, 

Start the scheduler. All ephemeral tasks are deleted.

fn dispatch_scheduled_fns<'async_trait>(
    self: Arc<Self>
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    Self: 'async_trait, 

Dispatch all due scheduled functions.

fn post_commit_permit<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<OwnedPermit<PostCommitArgs>, SendError<()>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get an OwnedPermit to the post commit task.

fn pause_app<'async_trait>(
    self: Arc<Self>,
    app_id: InstalledAppId,
    reason: PausedAppReason
) -> Pin<Box<dyn Future<Output = ConductorResult<InstalledApp>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Stop a running app while leaving it enabled. FOR TESTING ONLY.

fn list_cell_ids(&self, filter: Option<CellStatus>) -> Vec<CellId>

List Cell Ids

fn list_running_apps<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<InstalledAppId>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

List Active AppIds

fn list_apps<'life0, 'async_trait>(
    &'life0 self,
    status_filter: Option<AppStatusFilter>
) -> Pin<Box<dyn Future<Output = ConductorResult<Vec<InstalledAppInfo>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

List Apps with their information

fn list_running_apps_for_required_cell_id<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId
) -> Pin<Box<dyn Future<Output = ConductorResult<HashSet<InstalledAppId>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the IDs of all active installed Apps which use this Cell

fn list_running_apps_for_required_dna_hash<'life0, 'life1, 'async_trait>(
    &'life0 self,
    dna_hash: &'life1 DnaHash
) -> Pin<Box<dyn Future<Output = ConductorResult<HashSet<InstalledAppId>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get the IDs of all active installed Apps which use this Dna

fn dump_cell_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId
) -> Pin<Box<dyn Future<Output = ConductorApiResult<String>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Dump the cells state

fn dump_full_cell_state<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_id: &'life1 CellId,
    dht_ops_cursor: Option<u64>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<FullStateDump>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Dump the full cells state

fn dump_network_metrics<'life0, 'async_trait>(
    &'life0 self,
    dna_hash: Option<DnaHash>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<String>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Dump the network metrics

fn signal_broadcaster<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = SignalBroadcaster> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Access the broadcast Sender which will send a Signal across every attached app interface

fn get_app_info<'life0, 'life1, 'async_trait>(
    &'life0 self,
    installed_app_id: &'life1 InstalledAppId
) -> Pin<Box<dyn Future<Output = ConductorResult<Option<InstalledAppInfo>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Get info about an installed App, whether active or inactive

fn add_agent_infos<'life0, 'async_trait>(
    &'life0 self,
    agent_infos: Vec<AgentInfoSigned>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Add signed agent info to the conductor

fn get_agent_infos<'life0, 'async_trait>(
    &'life0 self,
    cell_id: Option<CellId>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<Vec<AgentInfoSigned>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Get signed agent info from the conductor

fn print_setup(&self)

Print the current setup in a machine readable way.

fn remove_cells<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cell_ids: &'life1 [CellId]
) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Manually remove some cells. Should only be used when handling errors in Cells, allowing individual Cells to be shut down.

fn insert_records_into_source_chain<'async_trait>(
    self: Arc<Self>,
    cell_id: CellId,
    truncate: bool,
    validate: bool,
    records: Vec<Record>
) -> Pin<Box<dyn Future<Output = ConductorApiResult<()>> + Send + 'async_trait>> where
    Self: 'async_trait, 

Inject records into a source chain for a cell.

fn get_authored_db(
    &self,
    cell_id: &DnaHash
) -> ConductorApiResult<DbWrite<DbKindAuthored>>

Retrieve the authored environment for this dna. FOR TESTING ONLY.

fn get_dht_db(
    &self,
    cell_id: &DnaHash
) -> ConductorApiResult<DbWrite<DbKindDht>>

Retrieve the dht environment for this dna. FOR TESTING ONLY.

fn get_dht_db_cache(
    &self,
    cell_id: &DnaHash
) -> ConductorApiResult<DhtDbQueryCache>

Retrieve the dht environment for this dna. FOR TESTING ONLY.

fn get_cache_db(
    &self,
    cell_id: &CellId
) -> ConductorApiResult<DbWrite<DbKindCache>>

Retrieve the database for this cell. FOR TESTING ONLY.

fn get_p2p_db(&self, space: &DnaHash) -> DbWrite<DbKindP2pAgents>

Retrieve the database for networking. FOR TESTING ONLY.

fn get_p2p_metrics_db(&self, space: &DnaHash) -> DbWrite<DbKindP2pMetrics>

Retrieve the database for metrics. FOR TESTING ONLY.

fn get_spaces(&self) -> Spaces

Retrieve the database for networking. FOR TESTING ONLY.

fn get_cell_triggers(
    &self,
    cell_id: &CellId
) -> ConductorApiResult<QueueTriggers>

Retrieve Senders for triggering workflows. FOR TESTING ONLY.

fn get_state_from_handle<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = ConductorApiResult<ConductorState>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Retrieve the ConductorState. FOR TESTING ONLY.

fn add_test_app_interface<'life0, 'async_trait>(
    &'life0 self,
    id: AppInterfaceId
) -> Pin<Box<dyn Future<Output = ConductorResult<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Add a “test” app interface for sending and receiving signals. FOR TESTING ONLY.

fn dev_settings(&self) -> DevSettings

Get the current dev settings

fn update_dev_settings(&self, delta: DevSettingsDelta)

Update the current dev settings

fn update_cell_status(&self, cell_ids: &[CellId], status: CellStatus)

Manually coerce cells to a given CellStatus. FOR TESTING ONLY.

fn transition_app_status<'life0, 'async_trait>(
    &'life0 self,
    app_id: InstalledAppId,
    transition: AppStatusTransition
) -> Pin<Box<dyn Future<Output = ConductorResult<(InstalledApp, AppStatusFx)>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Manually coerce app to a given AppStatus. FOR TESTING ONLY.

impl Debug for MockConductorHandleT

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for MockConductorHandleT

fn default() -> Self

Returns the “default value” for a type.