Struct holochain::sweettest::SweetConductor

pub struct SweetConductor { /* fields omitted */ }

A useful Conductor abstraction for testing, allowing startup and shutdown as well as easy installation of apps across multiple Conductors and Agents.

This is intentionally NOT Clone, because the drop handle triggers a shutdown of the conductor handle, which would render all other cloned instances useless. If you need multiple references to a SweetConductor, put it in an Arc

Implementations

impl SweetConductor

pub async fn new(
    handle: ConductorHandle,
    envs: TestEnvs,
    config: ConductorConfig
) -> SweetConductor

Create a SweetConductor from an already-built ConductorHandle and environments DnaStore The conductor will be supplied with a single test AppInterface named “sweet-interface” so that signals may be emitted

pub async fn from_config(config: ConductorConfig) -> SweetConductor

Create a SweetConductor with a new set of TestEnvs from the given config

pub async fn from_builder<DS: DnaStore + 'static>(
    builder: ConductorBuilder<DS>
) -> SweetConductor

Create a SweetConductor from a partially-configured ConductorBuilder

pub async fn handle_from_existing(
    envs: &TestEnvs,
    config: &ConductorConfig,
    extra_dnas: &[DnaFile]
) -> ConductorHandle

Create a handle from an existing environment and config

pub async fn from_standard_config() -> SweetConductor

Create a SweetConductor with a new set of TestEnvs from the given config

pub fn envs(&self) -> &TestEnvs

Access the TestEnvs for this conductor

pub fn keystore(&self) -> KeystoreSender

Access the KeystoreSender for this conductor

pub async fn enable_app(
    &self,
    id: InstalledAppId
) -> ConductorResult<(InstalledApp, Vec<(CellId, CellError)>)>

Convenience function that uses the internal handle to enable an app

pub async fn disable_app(
    &self,
    id: InstalledAppId,
    reason: DisabledAppReason
) -> ConductorResult<InstalledApp>

Convenience function that uses the internal handle to disable an app

pub async fn start_app(
    &self,
    id: InstalledAppId
) -> ConductorResult<InstalledApp>

Convenience function that uses the internal handle to start an app

pub async fn pause_app(
    &self,
    id: InstalledAppId,
    reason: PausedAppReason
) -> ConductorResult<InstalledApp>

Convenience function that uses the internal handle to pause an app

pub async fn setup_app_for_agent(
    &mut self,
    installed_app_id: &str,
    agent: AgentPubKey,
    dna_files: &[DnaFile]
) -> ConductorApiResult<SweetApp>

Opinionated app setup. Creates an app for the given agent, using the given DnaFiles, with no extra configuration.

pub async fn setup_app(
    &mut self,
    installed_app_id: &str,
    dna_files: &[DnaFile]
) -> ConductorApiResult<SweetApp>

Opinionated app setup. Creates an app using the given DnaFiles, with no extra configuration. An AgentPubKey will be generated, and is accessible via the returned SweetApp.

pub async fn setup_app_for_agents(
    &mut self,
    app_id_prefix: &str,
    agents: &[AgentPubKey],
    dna_files: &[DnaFile]
) -> ConductorApiResult<SweetAppBatch>

Opinionated app setup. Creates one app per agent, using the given DnaFiles.

All InstalledAppIds and CellNicks are auto-generated. In tests driven directly by Rust, you typically won’t care what these values are set to, but in case you do, they are set as so:

• InstalledAppId: {app_id_prefix}-{agent_pub_key}
• CellNick: {dna_hash}

Returns a batch of SweetApps, sorted in the same order as Agents passed in.

pub fn signals(&mut self) -> impl Stream<Item = Signal>

Get a stream of all Signals emitted on the “sweet-interface” AppInterface.

This is designed to crash if called more than once, because as currently implemented, creating multiple signal streams would simply cause multiple consumers of the same underlying streams, not a fresh subscription

pub async fn admin_ws_client(&self) -> (WebsocketSender, WebsocketReceiver)

Get a new websocket client which can send requests over the admin interface. It presupposes that an admin interface has been configured. (The standard_config includes an admin interface at port 0.)

pub async fn shutdown(&mut self)

Shutdown this conductor. This will wait for the conductor to shutdown but keep the inner state to restart it.

Attempting to use this conductor without starting it up again will cause a panic.

pub async fn startup(&mut self)

Start up this conductor if it’s not already running.

pub fn is_running(&self) -> bool

Check if this conductor is running

pub fn inner_handle(&self) -> ConductorHandle

Get the ConductorHandle within this Conductor. Be careful when using this, because this leaks out handles, which may make it harder to shut down the conductor during tests.

pub async fn force_all_publish_dht_ops(&self)

Force trigger all dht ops that haven’t received enough validation receipts yet.

Methods from Deref<Target = SweetConductorHandle>

pub fn handle(&self) -> ConductorHandle

Handle accessor.

pub async fn call<I, O, F>(&self, zome: &SweetZome, fn_name: F, payload: I) -> O where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug, 

Make a zome call to a Cell, as if that Cell were the caller. Most common case. No capability is necessary, since the authorship capability is automatically granted.

pub async fn call_fallible<I, O, F>(
    &self,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> ConductorApiResult<O> where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug, 

Like call, but without the unwrap

pub async fn call_from<I, O, F>(
    &self,
    provenance: &AgentPubKey,
    cap: Option<CapSecret>,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> O where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug, 

Make a zome call to a Cell, as if some other Cell were the caller. More general case. Can optionally provide a capability.

pub async fn call_from_fallible<I, O, F>(
    &self,
    provenance: &AgentPubKey,
    cap: Option<CapSecret>,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> ConductorApiResult<O> where
    FunctionName: From<F>,
    I: Serialize + Debug,
    O: DeserializeOwned + Debug, 

Like call_from, but without the unwrap

pub async fn shutdown_and_wait(&self)

Manually await shutting down the conductor. Conductors are already cleaned up on drop but this is useful if you need to know when it’s finished cleaning up.

Trait Implementations

impl AsRef<SweetConductorHandle> for SweetConductor

fn as_ref(&self) -> &SweetConductorHandle

Performs the conversion.

impl Borrow<SweetConductorHandle> for SweetConductor

fn borrow(&self) -> &SweetConductorHandle

Immutably borrows from an owned value.

impl Deref for SweetConductor

type Target = SweetConductorHandle

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for SweetConductor

fn drop(&mut self)

Executes the destructor for this type.

impl From<(Option<SweetConductorHandle>, TestEnvs, ConductorConfig, Vec<DnaFile, Global>, Option<Box<dyn Stream<Item = Signal> + Send + Sync + Unpin + 'static, Global>>)> for SweetConductor

fn from(
    original: (Option<SweetConductorHandle>, TestEnvs, ConductorConfig, Vec<DnaFile>, Option<SignalStream>)
) -> SweetConductor

Performs the conversion.