Struct holochain::sweettest::SweetConductor

pub struct SweetConductor { /* private fields */ }

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,
    env_dir: TestDir,
    config: ConductorConfig
) -> SweetConductor

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

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

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

pub async fn from_builder(builder: ConductorBuilder) -> SweetConductor

Create a SweetConductor from a partially-configured ConductorBuilder

pub async fn handle_from_existing(
    db_dir: &Path,
    keystore: MetaLairClient,
    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 db_path(&self) -> &Path

Access the database path for this conductor

pub fn persist(&mut self) -> &Path

Make the temp db dir persistent

pub fn keystore(&self) -> MetaLairClient

Access the MetaLairClient 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 fn get_sweet_cell(&self, cell_id: CellId) -> ConductorApiResult<SweetCell>

Construct a SweetCell for a cell which has already been created

pub async fn setup_app_for_agent<'a, R, D>(
    &mut self,
    installed_app_id: &str,
    agent: AgentPubKey,
    roles: D
) -> ConductorApiResult<SweetApp>where
    R: Into<DnaWithRole> + Clone + 'a,
    D: IntoIterator<Item = &'a R>,

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

pub async fn setup_app<'a, R, D>(
    &mut self,
    installed_app_id: &str,
    dnas: D
) -> ConductorApiResult<SweetApp>where
    R: Into<DnaWithRole> + Clone + 'a,
    D: IntoIterator<Item = &'a R> + Clone,

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<'a, A, R, D>(
    &mut self,
    app_id_prefix: &str,
    agents: A,
    roles: D
) -> ConductorApiResult<SweetAppBatch>where
    A: IntoIterator<Item = &'a AgentPubKey>,
    R: Into<DnaWithRole> + Clone + 'a,
    D: IntoIterator<Item = &'a R>,

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

All InstalledAppIds and RoleNames 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}
• RoleName: {dna_hash}

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

pub async fn create_clone_cell(
    &mut self,
    payload: CreateCloneCellPayload
) -> ConductorApiResult<ClonedCell>

Call into the underlying create_clone_cell function, and register the created dna with SweetConductor so it will be reloaded on restart.

pub fn signals(&mut self) -> SignalStream

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 raw_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.

pub async fn exchange_peer_info(conductors: impl IntoIterator<Item = &Self>)

Let each conductor know about each others’ agents so they can do networking

pub async fn exchange_peer_info_sampled(
    conductors: impl IntoIterator<Item = &Self>,
    rng: &mut StdRng,
    s: usize
)

Let each conductor know about each others’ agents so they can do networking

Methods from Deref<Target = SweetConductorHandle>

pub async fn call<I, O, F>(&self, zome: &SweetZome, fn_name: F, payload: I) -> Owhere
    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_secret: Option<CapSecret>,
    zome: &SweetZome,
    fn_name: F,
    payload: I
) -> Owhere
    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_secret: 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 signal_stream(&self) -> impl Stream<Item = Signal>

Get a stream of all Signals emitted since the time of this function call.

Trait Implementations

impl AsRef<SweetConductorHandle> for SweetConductor

fn as_ref(&self) -> &SweetConductorHandle

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<SweetConductorHandle> for SweetConductor

fn borrow(&self) -> &SweetConductorHandle

Immutably borrows from an owned value.

impl Debug for SweetConductor

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

Formats the value using the given formatter.

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>, TestDir, MetaLairClient, Spaces, ConductorConfig, Vec<DnaFile, Global>, Option<Box<dyn Stream<Item = Signal> + Sync + Send + Unpin + 'static, Global>>)> for SweetConductor

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

Converts to this type from the input type.