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
136
137
138
139
140
141
142
143
144
145
146
use crate::dna::wasm::DnaWasm;
use crate::fixt::*;
use crate::prelude::*;
use crate::record::SignedActionHashedExt;
use holochain_keystore::MetaLairClient;
use std::path::PathBuf;
pub use holochain_zome_types::test_utils::*;
#[allow(missing_docs)]
pub mod chain;
#[derive(Serialize, Deserialize, SerializedBytes, Debug)]
struct FakeProperties {
test: String,
}
pub fn fake_dna_file(network_seed: &str) -> DnaFile {
fake_dna_file_named(network_seed, "test")
}
pub fn fake_dna_file_named(network_seed: &str, name: &str) -> DnaFile {
fake_dna_zomes_named(network_seed, name, vec![(name.into(), vec![].into())])
}
pub fn fake_dna_zomes(network_seed: &str, zomes: Vec<(ZomeName, DnaWasm)>) -> DnaFile {
fake_dna_zomes_named(network_seed, "test", zomes)
}
pub fn fake_dna_zomes_named(
network_seed: &str,
name: &str,
zomes: Vec<(ZomeName, DnaWasm)>,
) -> DnaFile {
let mut dna = DnaDef {
name: name.to_string(),
properties: YamlProperties::new(serde_yaml::from_str("p: hi").unwrap())
.try_into()
.unwrap(),
network_seed: network_seed.to_string(),
origin_time: Timestamp::HOLOCHAIN_EPOCH,
integrity_zomes: Vec::new(),
coordinator_zomes: Vec::new(),
};
tokio_helper::block_forever_on(async move {
let mut wasm_code = Vec::new();
for (zome_name, wasm) in zomes {
let wasm = crate::dna::wasm::DnaWasmHashed::from_content(wasm).await;
let (wasm, wasm_hash) = wasm.into_inner();
dna.integrity_zomes.push((
zome_name,
ZomeDef::Wasm(WasmZome {
wasm_hash,
dependencies: Default::default(),
})
.into(),
));
wasm_code.push(wasm);
}
DnaFile::new(dna, wasm_code).await
})
.unwrap()
}
pub async fn write_fake_dna_file(dna: DnaFile) -> anyhow::Result<(PathBuf, tempfile::TempDir)> {
let bundle = DnaBundle::from_dna_file(dna).await?;
let tmp_dir = tempfile::Builder::new()
.prefix("fake_dna")
.tempdir()
.unwrap();
let mut path: PathBuf = tmp_dir.path().into();
path.push("test-dna.dna");
bundle.write_to_file(&path).await?;
Ok((path, tmp_dir))
}
pub fn which_agent(key: &AgentPubKey) -> String {
let key = key.to_string();
let alice = fake_agent_pubkey_1().to_string();
let bob = fake_agent_pubkey_2().to_string();
if key == alice {
return "alice".to_string();
}
if key == bob {
return "bob".to_string();
}
key
}
pub fn fake_cap_secret() -> CapSecret {
[0; CAP_SECRET_BYTES].into()
}
pub async fn fake_unique_record(
keystore: &MetaLairClient,
agent_key: AgentPubKey,
visibility: EntryVisibility,
) -> anyhow::Result<(SignedActionHashed, EntryHashed)> {
let content: SerializedBytes =
UnsafeBytes::from(nanoid::nanoid!().as_bytes().to_owned()).into();
let entry = Entry::App(content.try_into().unwrap()).into_hashed();
let app_entry_type = AppEntryTypeFixturator::new(visibility).next().unwrap();
let action_1 = Action::Create(Create {
author: agent_key,
timestamp: Timestamp::now(),
action_seq: 0,
prev_action: fake_action_hash(1),
entry_type: EntryType::App(app_entry_type),
entry_hash: entry.as_hash().to_owned(),
weight: Default::default(),
});
Ok((
SignedActionHashed::sign(keystore, action_1.into_hashed()).await?,
entry,
))
}
pub fn test_keystore() -> holochain_keystore::MetaLairClient {
tokio_helper::block_on(
async move {
let keystore = holochain_keystore::test_keystore::spawn_test_keystore()
.await
.unwrap();
keystore
},
std::time::Duration::from_secs(1),
)
.expect("timeout elapsed")
}