holochain 0.6.0

Holochain, a framework for distributed applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::sweettest::{SweetConductor, SweetDnaFile};
use holochain_conductor_api::CellInfo;
use holochain_types::prelude::*;
use holochain_wasm_test_utils::TestWasm;
use matches::matches;

#[tokio::test(flavor = "multi_thread")]
async fn app_info_returns_all_cells_with_info() {
    // set up app with two provisioned cells and one clone cell of each of them
    let (dna_1, _, _) = SweetDnaFile::unique_from_test_wasms(vec![TestWasm::Create]).await;
    let (dna_2, _, _) = SweetDnaFile::unique_from_test_wasms(vec![TestWasm::Create]).await;
    let mut conductor = SweetConductor::from_standard_config().await;

    let app_id: InstalledAppId = "app".into();
    let role_name_1: RoleName = "role_1".into();
    let role_name_2: RoleName = "role_2".into();
    let app = conductor
        .setup_app(
            &app_id,
            [
                &(role_name_1.clone(), dna_1.clone()),
                &(role_name_2.clone(), dna_2.clone()),
            ],
        )
        .await
        .unwrap();
    let agent_pub_key = app.agent().clone();

    // create 1 clone cell for role 1 = clone cell 1
    let clone_cell_1 = conductor
        .clone()
        .create_clone_cell(
            &app_id,
            CreateCloneCellPayload {
                role_name: role_name_1.clone(),
                modifiers: DnaModifiersOpt::none().with_network_seed("seed numero uno".to_string()),
                membrane_proof: None,
                name: None,
            },
        )
        .await
        .unwrap();
    assert_eq!(clone_cell_1.original_dna_hash, dna_1.dna_hash().clone());

    // create 1 clone cell for role 2 = clone cell 2
    let clone_cell_2 = conductor
        .clone()
        .create_clone_cell(
            &app_id,
            CreateCloneCellPayload {
                role_name: role_name_2.clone(),
                modifiers: DnaModifiersOpt::none().with_network_seed("seed numero dos".to_string()),
                membrane_proof: None,
                name: None,
            },
        )
        .await
        .unwrap();
    assert_eq!(clone_cell_2.original_dna_hash, dna_2.dna_hash().clone());

    // disable clone cell 2
    conductor
        .disable_clone_cell(
            &app_id,
            &DisableCloneCellPayload {
                clone_cell_id: CloneCellId::DnaHash(clone_cell_2.cell_id.dna_hash().clone()),
            },
        )
        .await
        .unwrap();

    let app_info = conductor.get_app_info(&app_id).await.unwrap().unwrap();

    // agent pub key matches
    assert_eq!(app_info.agent_pub_key, agent_pub_key);

    // app info has cell info for two role names
    assert_eq!(app_info.cell_info.len(), 2);

    // check cell info for role name 1
    let cell_info_for_role_1 = app_info.cell_info.get(&role_name_1).unwrap();
    // cell 1 in cell info is provisioned cell
    matches!(cell_info_for_role_1[0], CellInfo::Provisioned(_));
    // cell 2 in cell info is clone cell
    matches!(cell_info_for_role_1[1], CellInfo::Cloned(_));

    // check cell info for role name 2
    let cell_info_for_role_2 = app_info.cell_info.get(&role_name_2).unwrap();
    // cell 1 in cell info is provisioned cell
    matches!(cell_info_for_role_2[0], CellInfo::Provisioned(_));
    // cell 2 in cell info is clone cell
    matches!(cell_info_for_role_2[1], CellInfo::Cloned(_));

    // clone cell ids match
    assert!(if let CellInfo::Cloned(cell) = &cell_info_for_role_1[1] {
        cell.cell_id == clone_cell_1.cell_id.clone()
    } else {
        false
    });

    assert!(if let CellInfo::Cloned(cell) = &cell_info_for_role_2[1] {
        cell.cell_id == clone_cell_2.cell_id.clone()
    } else {
        false
    });

    conductor.shutdown().await;
    conductor.startup(false).await;

    // make sure app info is identical after conductor restart
    let app_info_after_restart = conductor
        .clone()
        .get_app_info(&app_id)
        .await
        .unwrap()
        .unwrap();
    assert_eq!(app_info, app_info_after_restart);

    // make sure the re-enabled clone cell's original DNA hash matches
    // tests that the enable_clone_cell fn returns the right DNA hash
    let reenabled_clone_cell = conductor
        .clone()
        .enable_clone_cell(
            &app_id,
            &EnableCloneCellPayload {
                clone_cell_id: CloneCellId::DnaHash(clone_cell_2.cell_id.dna_hash().clone()),
            },
        )
        .await
        .unwrap();
    assert_eq!(
        reenabled_clone_cell.original_dna_hash,
        dna_2.dna_hash().clone()
    );
}