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

use crate::prelude::InitCallbackResult;
use crate::sweettest::{SweetConductor, SweetDnaFile};
use crate::test_utils::retry_fn_until_timeout;
use holochain_wasm_test_utils::TestWasm;

#[tokio::test(flavor = "multi_thread")]
async fn check_or_run_zome_init_triggers_zome_initialization() {
    let zome = TestWasm::InitPass;
    let (dna, _, _) = SweetDnaFile::unique_from_test_wasms(vec![zome]).await;
    let mut conductor = SweetConductor::from_standard_config().await;
    let app = conductor.setup_app("app", [&dna]).await.unwrap();
    let cell_id = app.cells()[0].cell_id();

    // Wait for integration workflow to complete
    retry_fn_until_timeout(
        || async { conductor.all_ops_integrated(dna.dna_hash()).unwrap() },
        None,
        None,
    )
    .await
    .unwrap();

    // Take state dump before calling check_or_run_zome_init
    let before_state_dump = conductor
        .raw_handle()
        .dump_full_cell_state(cell_id, None)
        .await
        .expect("Failed to get state dump");

    // Init zomes, so that all genesis records are committed
    let cell = conductor
        .raw_handle()
        .cell_by_id(cell_id)
        .await
        .expect("failed to get cell");
    cell.check_or_run_zome_init()
        .await
        .expect("failed to init cell");

    // Wait for integration workflow to complete
    retry_fn_until_timeout(
        || async { conductor.all_ops_integrated(dna.dna_hash()).unwrap() },
        None,
        None,
    )
    .await
    .unwrap();

    // Take state dump after calling check_or_run_zome_init
    let after_state_dump = conductor
        .raw_handle()
        .dump_full_cell_state(cell_id, None)
        .await
        .expect("Failed to get state dump");

    // 2 new DhtOps for InitZomesComplete are integrated into the source chain
    assert_eq!(
        after_state_dump.integration_dump.integrated.len()
            - before_state_dump.integration_dump.integrated.len(),
        2
    );
    assert_eq!(after_state_dump.integration_dump.integration_limbo.len(), 0);
}

#[tokio::test(flavor = "multi_thread")]
async fn check_or_run_zome_init_does_nothing_if_already_initialized() {
    let zome = TestWasm::InitPass;
    let (dna, _, _) = SweetDnaFile::unique_from_test_wasms(vec![zome]).await;
    let mut conductor = SweetConductor::from_standard_config().await;
    let app = conductor.setup_app("app", [&dna]).await.unwrap();
    let cell_id = app.cells()[0].cell_id();
    let sweet_zome = app.cells()[0].zome(TestWasm::InitPass);

    // Trigger init.
    let _: InitCallbackResult = conductor.call(&sweet_zome, "init", ()).await;

    // Wait for integration workflow to complete
    retry_fn_until_timeout(
        || async { conductor.all_ops_integrated(dna.dna_hash()).unwrap() },
        None,
        None,
    )
    .await
    .unwrap();

    // Take state dump before calling check_or_run_zome_init
    let before_state_dump = conductor
        .raw_handle()
        .dump_full_cell_state(cell_id, None)
        .await
        .expect("Failed to get state dump");

    // Init zomes, so that all genesis records are committed
    let cell = conductor
        .raw_handle()
        .cell_by_id(cell_id)
        .await
        .expect("failed to get cell");
    cell.check_or_run_zome_init()
        .await
        .expect("failed to init cell");

    // Wait for integration workflow to complete
    retry_fn_until_timeout(
        || async { conductor.all_ops_integrated(dna.dna_hash()).unwrap() },
        None,
        None,
    )
    .await
    .unwrap();

    // Take state dump after calling check_or_run_zome_init
    let after_state_dump = conductor
        .raw_handle()
        .dump_full_cell_state(cell_id, None)
        .await
        .expect("Failed to get state dump");

    // DhtOps integrated have not changed, because initialization was already run
    assert_eq!(
        after_state_dump.integration_dump.integrated.len()
            - before_state_dump.integration_dump.integrated.len(),
        0
    );
}