Skip to content

Commit 876db8c

Browse files
altkdfaltkdf
committed
fix tests
1 parent e999f95 commit 876db8c

File tree

9 files changed

+176
-70
lines changed

9 files changed

+176
-70
lines changed

‎Cargo.lock‎

Lines changed: 3 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎backend/mo/canisters/ic_vetkeys_encrypted_maps_canister/src/Main.mo‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,9 @@ import Result "mo:base/Result";
77
import Array "mo:base/Array";
88

99
persistent actor class (keyName : Text) {
10-
let encryptedMapsState = IcVetkeys.EncryptedMaps.newEncryptedMapsState<Types.AccessRights>(
11-
{ curve = #bls12_381_g2; name = keyName },
12-
"encrypted maps dapp",
13-
);
10+
let encryptedMapsState = IcVetkeys.EncryptedMaps.newEncryptedMapsState<Types.AccessRights>({ curve = #bls12_381_g2; name = "" }, "encrypted maps dapp");
11+
encryptedMapsState.keyManager.vetKdKeyId := { curve = #bls12_381_g2; name = keyName };
12+
transient let encryptedMaps = IcVetkeys.EncryptedMaps.EncryptedMaps<Types.AccessRights>(encryptedMapsState, Types.accessRightsOperations());
1413

1514
/// In this canister, we use the `ByteBuf` type to represent blobs. The reason is that we want to be consistent with the Rust canister implementation.
1615
/// Unfortunately, the `Blob` type cannot be serialized/deserialized in the current Rust implementation efficiently without nesting it in another type.
@@ -35,7 +34,7 @@ persistent actor class (keyName : Text) {
3534

3635
public query (msg) func get_accessible_shared_map_names() : async [(Principal, ByteBuf)] {
3736
Array.map<(Principal, Blob), (Principal, ByteBuf)>(
38-
getEncryptedMaps().getAccessibleSharedMapNames(msg.caller),
37+
encryptedMaps.getAccessibleSharedMapNames(msg.caller),
3938

4039
func((principal, blob) : (Principal, Blob)) {
4140
(principal, { inner = blob });
@@ -47,14 +46,14 @@ persistent actor class (keyName : Text) {
4746
map_owner : Principal,
4847
map_name : ByteBuf,
4948
) : async Result<[(Principal, Types.AccessRights)], Text> {
50-
convertResult(getEncryptedMaps().getSharedUserAccessForMap(msg.caller, (map_owner, map_name.inner)));
49+
convertResult(encryptedMaps.getSharedUserAccessForMap(msg.caller, (map_owner, map_name.inner)));
5150
};
5251

5352
public query (msg) func get_encrypted_values_for_map(
5453
map_owner : Principal,
5554
map_name : ByteBuf,
5655
) : async Result<[(ByteBuf, ByteBuf)], Text> {
57-
let result = getEncryptedMaps().getEncryptedValuesForMap(msg.caller, (map_owner, map_name.inner));
56+
let result = encryptedMaps.getEncryptedValuesForMap(msg.caller, (map_owner, map_name.inner));
5857
switch (result) {
5958
case (#err(e)) { #Err(e) };
6059
case (#ok(values)) {
@@ -72,7 +71,7 @@ persistent actor class (keyName : Text) {
7271

7372
public query (msg) func get_all_accessible_encrypted_values() : async [((Principal, ByteBuf), [(ByteBuf, ByteBuf)])] {
7473
Array.map<((Principal, Blob), [(Blob, Blob)]), ((Principal, ByteBuf), [(ByteBuf, ByteBuf)])>(
75-
getEncryptedMaps().getAllAccessibleEncryptedValues(msg.caller),
74+
encryptedMaps.getAllAccessibleEncryptedValues(msg.caller),
7675
func(((owner, map_name), values) : ((Principal, Blob), [(Blob, Blob)])) {
7776
(
7877
(owner, { inner = map_name }),
@@ -89,7 +88,7 @@ persistent actor class (keyName : Text) {
8988

9089
public query (msg) func get_all_accessible_encrypted_maps() : async [EncryptedMapData] {
9190
Array.map<IcVetkeys.EncryptedMaps.EncryptedMapData<Types.AccessRights>, EncryptedMapData>(
92-
getEncryptedMaps().getAllAccessibleEncryptedMaps(msg.caller),
91+
encryptedMaps.getAllAccessibleEncryptedMaps(msg.caller),
9392
func(map : IcVetkeys.EncryptedMaps.EncryptedMapData<Types.AccessRights>) : EncryptedMapData {
9493
{
9594
map_owner = map.map_owner;
@@ -111,7 +110,7 @@ persistent actor class (keyName : Text) {
111110
map_name : ByteBuf,
112111
map_key : ByteBuf,
113112
) : async Result<?ByteBuf, Text> {
114-
let result = getEncryptedMaps().getEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner);
113+
let result = encryptedMaps.getEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner);
115114
switch (result) {
116115
case (#err(e)) { #Err(e) };
117116
case (#ok(null)) { #Ok(null) };
@@ -123,7 +122,7 @@ persistent actor class (keyName : Text) {
123122
map_owner : Principal,
124123
map_name : ByteBuf,
125124
) : async Result<[ByteBuf], Text> {
126-
let result = getEncryptedMaps().removeMapValues(msg.caller, (map_owner, map_name.inner));
125+
let result = encryptedMaps.removeMapValues(msg.caller, (map_owner, map_name.inner));
127126
switch (result) {
128127
case (#err(e)) { #Err(e) };
129128
case (#ok(values)) {
@@ -141,7 +140,7 @@ persistent actor class (keyName : Text) {
141140

142141
public query (msg) func get_owned_non_empty_map_names() : async [ByteBuf] {
143142
Array.map<Blob, ByteBuf>(
144-
getEncryptedMaps().getOwnedNonEmptyMapNames(msg.caller),
143+
encryptedMaps.getOwnedNonEmptyMapNames(msg.caller),
145144
func(blob : Blob) : ByteBuf {
146145
{ inner = blob };
147146
},
@@ -154,7 +153,8 @@ persistent actor class (keyName : Text) {
154153
map_key : ByteBuf,
155154
value : ByteBuf,
156155
) : async Result<?ByteBuf, Text> {
157-
let result = getEncryptedMaps().insertEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner, value.inner);
156+
let result = encryptedMaps.insertEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner, value.inner);
157+
158158
switch (result) {
159159
case (#err(e)) { #Err(e) };
160160
case (#ok(null)) { #Ok(null) };
@@ -167,7 +167,7 @@ persistent actor class (keyName : Text) {
167167
map_name : ByteBuf,
168168
map_key : ByteBuf,
169169
) : async Result<?ByteBuf, Text> {
170-
let result = getEncryptedMaps().removeEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner);
170+
let result = encryptedMaps.removeEncryptedValue(msg.caller, (map_owner, map_name.inner), map_key.inner);
171171
switch (result) {
172172
case (#err(e)) { #Err(e) };
173173
case (#ok(null)) { #Ok(null) };
@@ -176,7 +176,7 @@ persistent actor class (keyName : Text) {
176176
};
177177

178178
public shared func get_vetkey_verification_key() : async ByteBuf {
179-
let inner = await getEncryptedMaps().getVetkeyVerificationKey();
179+
let inner = await encryptedMaps.getVetkeyVerificationKey();
180180
{ inner };
181181
};
182182

@@ -185,7 +185,7 @@ persistent actor class (keyName : Text) {
185185
map_name : ByteBuf,
186186
transport_key : ByteBuf,
187187
) : async Result<ByteBuf, Text> {
188-
let result = await getEncryptedMaps().getEncryptedVetkey(msg.caller, (map_owner, map_name.inner), transport_key.inner);
188+
let result = await encryptedMaps.getEncryptedVetkey(msg.caller, (map_owner, map_name.inner), transport_key.inner);
189189
switch (result) {
190190
case (#err(e)) { #Err(e) };
191191
case (#ok(vetkey)) { #Ok({ inner = vetkey }) };
@@ -197,7 +197,7 @@ persistent actor class (keyName : Text) {
197197
map_name : ByteBuf,
198198
user : Principal,
199199
) : async Result<?Types.AccessRights, Text> {
200-
convertResult(getEncryptedMaps().getUserRights(msg.caller, (map_owner, map_name.inner), user));
200+
convertResult(encryptedMaps.getUserRights(msg.caller, (map_owner, map_name.inner), user));
201201
};
202202

203203
public shared (msg) func set_user_rights(
@@ -206,15 +206,15 @@ persistent actor class (keyName : Text) {
206206
user : Principal,
207207
access_rights : Types.AccessRights,
208208
) : async Result<?Types.AccessRights, Text> {
209-
convertResult(getEncryptedMaps().setUserRights(msg.caller, (map_owner, map_name.inner), user, access_rights));
209+
convertResult(encryptedMaps.setUserRights(msg.caller, (map_owner, map_name.inner), user, access_rights));
210210
};
211211

212212
public shared (msg) func remove_user(
213213
map_owner : Principal,
214214
map_name : ByteBuf,
215215
user : Principal,
216216
) : async Result<?Types.AccessRights, Text> {
217-
convertResult(getEncryptedMaps().removeUser(msg.caller, (map_owner, map_name.inner), user));
217+
convertResult(encryptedMaps.removeUser(msg.caller, (map_owner, map_name.inner), user));
218218
};
219219

220220
/// Convert to the result type compatible with Rust's `Result`

‎backend/mo/canisters/ic_vetkeys_manager_canister/src/Main.mo‎

Lines changed: 10 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -7,11 +7,9 @@ import Result "mo:base/Result";
77
import Array "mo:base/Array";
88

99
persistent actor class (keyName : Text) {
10-
let keyManagerState = IcVetkeys.KeyManager.newKeyManagerState<Types.AccessRights>({ curve = #bls12_381_g2; name = keyName }, "key manager");
11-
12-
func getKeyManager() : IcVetkeys.KeyManager.KeyManager<Types.AccessRights> {
13-
IcVetkeys.KeyManager.KeyManager<Types.AccessRights>(keyManagerState, Types.accessRightsOperations());
14-
};
10+
let keyManagerState = IcVetkeys.KeyManager.newKeyManagerState<Types.AccessRights>({ curve = #bls12_381_g2; name = "" }, "key manager");
11+
keyManagerState.vetKdKeyId := { curve = #bls12_381_g2; name = keyName };
12+
transient let keyManager = IcVetkeys.KeyManager.KeyManager<Types.AccessRights>(keyManagerState, Types.accessRightsOperations());
1513

1614
/// In this canister, we use the `ByteBuf` type to represent blobs. The reason is that we want to be consistent with the Rust canister implementation.
1715
/// Unfortunately, the `Blob` type cannot be serialized/deserialized in the current Rust implementation efficiently without nesting it in another type.
@@ -25,7 +23,7 @@ persistent actor class (keyName : Text) {
2523

2624
public query (msg) func get_accessible_shared_key_ids() : async [(Principal, ByteBuf)] {
2725
Array.map<(Principal, Blob), (Principal, ByteBuf)>(
28-
getKeyManager().getAccessibleSharedKeyIds(msg.caller),
26+
keyManager.getAccessibleSharedKeyIds(msg.caller),
2927
func((principal, blob) : (Principal, Blob)) {
3028
(principal, { inner = blob });
3129
},
@@ -36,11 +34,11 @@ persistent actor class (keyName : Text) {
3634
key_owner : Principal,
3735
key_name : ByteBuf,
3836
) : async Result<[(Principal, Types.AccessRights)], Text> {
39-
convertResult(getKeyManager().getSharedUserAccessForKey(msg.caller, (key_owner, key_name.inner)));
37+
convertResult(keyManager.getSharedUserAccessForKey(msg.caller, (key_owner, key_name.inner)));
4038
};
4139

4240
public shared func get_vetkey_verification_key() : async ByteBuf {
43-
let inner = await getKeyManager().getVetkeyVerificationKey();
41+
let inner = await keyManager.getVetkeyVerificationKey();
4442
{ inner };
4543
};
4644

@@ -49,7 +47,7 @@ persistent actor class (keyName : Text) {
4947
key_name : ByteBuf,
5048
transport_key : ByteBuf,
5149
) : async Result<ByteBuf, Text> {
52-
let vetkeyBytebuf = await getKeyManager().getEncryptedVetkey(msg.caller, (key_owner, key_name.inner), transport_key.inner);
50+
let vetkeyBytebuf = await keyManager.getEncryptedVetkey(msg.caller, (key_owner, key_name.inner), transport_key.inner);
5351
switch (vetkeyBytebuf) {
5452
case (#err(e)) { #Err(e) };
5553
case (#ok(inner)) { #Ok({ inner }) };
@@ -61,7 +59,7 @@ persistent actor class (keyName : Text) {
6159
key_name : ByteBuf,
6260
user : Principal,
6361
) : async Result<?Types.AccessRights, Text> {
64-
convertResult(getKeyManager().getUserRights(msg.caller, (key_owner, key_name.inner), user));
62+
convertResult(keyManager.getUserRights(msg.caller, (key_owner, key_name.inner), user));
6563
};
6664

6765
public shared (msg) func set_user_rights(
@@ -70,15 +68,15 @@ persistent actor class (keyName : Text) {
7068
user : Principal,
7169
access_rights : Types.AccessRights,
7270
) : async Result<?Types.AccessRights, Text> {
73-
convertResult(getKeyManager().setUserRights(msg.caller, (key_owner, key_name.inner), user, access_rights));
71+
convertResult(keyManager.setUserRights(msg.caller, (key_owner, key_name.inner), user, access_rights));
7472
};
7573

7674
public shared (msg) func remove_user(
7775
key_owner : Principal,
7876
key_name : ByteBuf,
7977
user : Principal,
8078
) : async Result<?Types.AccessRights, Text> {
81-
convertResult(getKeyManager().removeUserRights(msg.caller, (key_owner, key_name.inner), user));
79+
convertResult(keyManager.removeUserRights(msg.caller, (key_owner, key_name.inner), user));
8280
};
8381

8482
/// Convert to the result type compatible with Rust's `Result`

‎backend/mo/ic_vetkeys/src/key_manager/KeyManager.mo‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -91,15 +91,15 @@ module {
9191
public type KeyManagerState<T> = {
9292
var accessControl : OrderedMap.Map<Principal, [(KeyId, T)]>;
9393
var sharedKeys : OrderedMap.Map<KeyId, [Principal]>;
94-
vetKdKeyId : ManagementCanister.VetKdKeyid;
94+
var vetKdKeyId : ManagementCanister.VetKdKeyid;
9595
domainSeparator : Text;
9696
};
9797

9898
public func newKeyManagerState<T>(vetKdKeyId : ManagementCanister.VetKdKeyid, domainSeparator : Text) : KeyManagerState<T> {
9999
{
100100
var accessControl = accessControlMapOps().empty();
101101
var sharedKeys = sharedKeysMapOps().empty();
102-
vetKdKeyId;
102+
var vetKdKeyId = vetKdKeyId;
103103
domainSeparator;
104104
};
105105
};

‎backend/rs/canisters/ic_vetkeys_encrypted_maps_canister/Cargo.toml‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ serde = "1.0.217"
2323

2424
[dev-dependencies]
2525
assert_matches = "1.5.0"
26+
ic-vetkeys-test-utils = { path = "../../ic_vetkeys_test_utils" }
2627
pocket-ic = "9.0.0"
2728
rand = "0.8.5"
2829
rand_chacha = "0.3.1"

‎backend/rs/canisters/ic_vetkeys_encrypted_maps_canister/tests/tests.rs‎

Lines changed: 51 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ use ic_vetkeys::encrypted_maps::{VetKey, VetKeyVerificationKey};
66
use ic_vetkeys::key_manager::key_id_to_vetkd_input;
77
use ic_vetkeys::types::{AccessControl, AccessRights, ByteBuf, TransportKey};
88
use ic_vetkeys::{DerivedPublicKey, EncryptedVetKey, TransportSecretKey};
9+
use ic_vetkeys_test_utils::upgrade_for_enhanced_orthogonal_persistence;
910
use pocket_ic::{PocketIc, PocketIcBuilder};
1011
use rand::{CryptoRng, Rng, SeedableRng};
1112
use rand_chacha::ChaCha20Rng;
@@ -896,15 +897,35 @@ fn should_survive_canister_upgrade() {
896897
)
897898
.unwrap();
898899

899-
let wasm_bytes = load_encrypted_maps_example_canister_wasm();
900-
env.pic
901-
.upgrade_canister(
900+
let obtained_value = env
901+
.query::<Result<Option<ByteBuf>, String>>(
902+
env.principal_0,
903+
"get_encrypted_value",
904+
encode_args((env.principal_0, map_name.clone(), map_key.clone())).unwrap(),
905+
)
906+
.unwrap();
907+
908+
assert_eq!(obtained_value, Some(encrypted_value.clone()));
909+
910+
let (wasm_bytes, enhanced_orthogonal_persistence) = load_encrypted_maps_example_canister_wasm();
911+
912+
if enhanced_orthogonal_persistence {
913+
upgrade_for_enhanced_orthogonal_persistence(
914+
&env.pic,
902915
env.example_canister_id,
903916
wasm_bytes,
904917
encode_one("dfx_test_key").unwrap(),
905-
None,
906-
)
907-
.unwrap();
918+
);
919+
} else {
920+
env.pic
921+
.upgrade_canister(
922+
env.example_canister_id,
923+
wasm_bytes,
924+
encode_one("dfx_test_key").unwrap(),
925+
None,
926+
)
927+
.unwrap();
928+
}
908929

909930
let encrypted_vetkey_1 = env
910931
.update::<Result<VetKey, String>>(
@@ -929,7 +950,10 @@ fn should_survive_canister_upgrade() {
929950
)
930951
.unwrap();
931952

932-
assert_eq!(obtained_value, Some(encrypted_value.clone()));
953+
assert!(
954+
obtained_value == Some(encrypted_value.clone()),
955+
"{obtained_value:?}"
956+
);
933957
}
934958

935959
pub fn reproducible_rng() -> ChaCha20Rng {
@@ -957,7 +981,7 @@ impl TestEnvironment {
957981
let example_canister_id = pic.create_canister();
958982
pic.add_cycles(example_canister_id, 2_000_000_000_000);
959983

960-
let example_wasm_bytes = load_encrypted_maps_example_canister_wasm();
984+
let (example_wasm_bytes, _) = load_encrypted_maps_example_canister_wasm();
961985
pic.install_canister(
962986
example_canister_id,
963987
example_wasm_bytes,
@@ -1007,17 +1031,26 @@ impl TestEnvironment {
10071031
}
10081032
}
10091033

1010-
fn load_encrypted_maps_example_canister_wasm() -> Vec<u8> {
1011-
let wasm_path_string = match std::env::var("CUSTOM_WASM_PATH") {
1012-
Ok(path) if !path.is_empty() => path,
1013-
_ => format!(
1014-
"{}/target/wasm32-unknown-unknown/release/ic_vetkeys_encrypted_maps_canister.wasm",
1015-
git_root_dir()
1016-
),
1017-
};
1034+
fn load_encrypted_maps_example_canister_wasm() -> (Vec<u8>, bool) {
1035+
let (wasm_path_string, enhanced_orthogonal_persistence) =
1036+
match std::env::var("CUSTOM_WASM_PATH") {
1037+
Ok(path) if !path.is_empty() => (path, true),
1038+
_ => (
1039+
format!(
1040+
"{}/target/wasm32-unknown-unknown/release/ic_vetkeys_encrypted_maps_canister.wasm",
1041+
git_root_dir()
1042+
),
1043+
false,
1044+
),
1045+
};
10181046
let wasm_path = Path::new(&wasm_path_string);
1019-
std::fs::read(wasm_path)
1020-
.expect("wasm does not exist - run `cargo build --release --target wasm32-unknown-unknown`")
1047+
1048+
(
1049+
std::fs::read(wasm_path).expect(
1050+
"wasm does not exist - run `cargo build --release --target wasm32-unknown-unknown`",
1051+
),
1052+
enhanced_orthogonal_persistence,
1053+
)
10211054
}
10221055

10231056
fn random_transport_key<R: Rng + CryptoRng>(rng: &mut R) -> TransportSecretKey {

0 commit comments

Comments
 (0)