samehabouelsaad/sal-modular
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implement browser extension UI with WebAssembly integration

Browse Source
This commit is contained in:
Sameh Abouel-saad
2025-05-22 11:53:32 +03:00
parent 13945a8725
commit ed76ba3d8d
74 changed files with 7054 additions and 577 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
vault/tests/session_manager.rs
View File

@@ -15,17 +15,21 @@ async fn session_manager_end_to_end() {
let keyspace = "personal";
let password = b"testpass";
// Create keyspace
vault.create_keyspace(keyspace, password, None).await.expect("create_keyspace");
// Add keypair
let key_id = vault.add_keypair(keyspace, password, Some(KeyType::Secp256k1), Some(KeyMetadata { name: Some("main".to_string()), created_at: None, tags: None })).await.expect("add_keypair");
// Create session manager
let mut session = SessionManager::new(vault);
session.unlock_keyspace(keyspace, password).await.expect("unlock_keyspace");
session.select_keyspace(keyspace).expect("select_keyspace");
// Create and unlock keyspace in one step
session.create_keyspace(keyspace, password, None).await.expect("create_keyspace via session");
// Add keypair using session API
let key_id = session.add_keypair(Some(KeyType::Secp256k1), Some(KeyMetadata { name: Some("main".to_string()), created_at: None, tags: None })).await.expect("add_keypair via session");
session.select_keypair(&key_id).expect("select_keypair");
// Test add_keypair with metadata via SessionManager
let meta = KeyMetadata { name: Some("user1-key".to_string()), created_at: None, tags: Some(vec!["tag1".to_string()]) };
let key_id2 = session.add_keypair(Some(KeyType::Ed25519), Some(meta.clone())).await.expect("add_keypair via session");
// List keypairs and check metadata
let keypairs = session.list_keypairs().expect("list_keypairs");
assert!(keypairs.iter().any(|k| k.id == key_id2 && k.metadata.as_ref().unwrap().name.as_deref() == Some("user1-key")), "metadata name should be present");
// Sign and verify
let msg = b"hello world";
let sig = session.sign(msg).await.expect("sign");
@@ -55,7 +59,8 @@ async fn session_manager_errors() {
let vault = Vault::new(store);
let mut session = SessionManager::new(vault);
// No keyspace unlocked
assert!(session.select_keyspace("none").is_err());
// select_keyspace removed; test unlocking a non-existent keyspace or selecting a keypair from an empty keyspace instead.
assert!(session.select_keypair("none").is_err());
assert!(session.select_keypair("none").is_err());
assert!(session.sign(b"fail").await.is_err());
}

2
vault/tests/wasm_keypair_management.rs
View File

@@ -16,7 +16,7 @@ async fn test_keypair_management_and_crypto() {
// All imports are WASM-specific and local to the test function
use kvstore::wasm::WasmStore;
use vault::Vault;
let store = WasmStore::open("testdb_wasm_keypair_management").await.unwrap();
let store = WasmStore::open("vault").await.unwrap();
let mut vault = Vault::new(store);
vault.create_keyspace("testspace", b"pw", None).await.unwrap();
let key_id = vault.add_keypair("testspace", b"pw", None, None).await.unwrap();

72
vault/tests/wasm_session_manager.rs
View File

@@ -11,19 +11,65 @@ use vault::Vault;
wasm_bindgen_test_configure!(run_in_browser);
#[wasm_bindgen_test(async)]
async fn test_session_manager_end_to_end() {
// Example: test session manager logic in WASM
// This is a placeholder for your real test logic.
// All imports are WASM-specific and local to the test function
async fn test_session_manager_lock_unlock_keypairs_persistence() {
use kvstore::wasm::WasmStore;
use vault::{Vault, KeyType, KeyMetadata};
use vault::session::SessionManager;
let store = WasmStore::open("testdb_wasm_session_manager").await.unwrap();
let vault = Vault::new(store);
let mut manager = SessionManager::new(vault);
let keyspace = "testspace";
// This test can only check session initialization/select_keyspace logic as SessionManager does not create keypairs directly.
// manager.select_keyspace(keyspace) would fail unless the keyspace exists.
// For a true end-to-end test, use Vault to create the keyspace and keypair, then test SessionManager.
// For now, just test that SessionManager can be constructed.
assert!(manager.current_keyspace().is_none());
let store = WasmStore::open("test-session-manager-lock-unlock").await.unwrap();
let mut vault = Vault::new(store);
let keyspace = "testspace2";
let password = b"testpass2";
// 1. Create session manager
let mut session = SessionManager::new(vault);
// Create and unlock keyspace in one step
session.create_keyspace(keyspace, password, None).await.expect("create_keyspace via session");
// 2. Add two keypairs with names using session API
let meta1 = KeyMetadata { name: Some("keypair-one".to_string()), created_at: None, tags: None };
let meta2 = KeyMetadata { name: Some("keypair-two".to_string()), created_at: None, tags: None };
let id1 = session.add_keypair(Some(KeyType::Secp256k1), Some(meta1.clone())).await.expect("add_keypair1 via session");
let id2 = session.add_keypair(Some(KeyType::Ed25519), Some(meta2.clone())).await.expect("add_keypair2 via session");
// 3. List, store keys and names
let keypairs_before = session.list_keypairs().expect("list_keypairs before").iter().map(|k| (k.id.clone(), k.public_key.clone(), k.private_key.clone(), k.metadata.clone())).collect::<Vec<_>>();
let keypairs_before = session.list_keypairs().expect("list_keypairs before").iter().map(|k| (k.id.clone(), k.public_key.clone(), k.private_key.clone(), k.metadata.clone())).collect::<Vec<_>>();
assert_eq!(keypairs_before.len(), 2);
assert!(keypairs_before.iter().any(|k| k.0 == id1 && k.3.as_ref().unwrap().name.as_deref() == Some("keypair-one")));
assert!(keypairs_before.iter().any(|k| k.0 == id2 && k.3.as_ref().unwrap().name.as_deref() == Some("keypair-two")));
// 4. Lock (logout)
session.logout();
assert!(session.current_keyspace().is_none());
// 5. Unlock again
session.unlock_keyspace(keyspace, password).await.expect("unlock_keyspace again");
// select_keyspace removed; unlocking a keyspace is sufficient after refactor.
// 6. List and check keys/names match
let keypairs_after = session.list_keypairs().expect("list_keypairs after").iter().map(|k| (k.id.clone(), k.public_key.clone(), k.private_key.clone(), k.metadata.clone())).collect::<Vec<_>>();
assert_eq!(keypairs_before, keypairs_after, "Keypairs before and after lock/unlock should match");
}
#[wasm_bindgen_test(async)]
async fn test_session_manager_end_to_end() {
use kvstore::wasm::WasmStore;
use vault::{Vault, KeyType, KeyMetadata};
use vault::session::SessionManager;
let store = WasmStore::open("test-session-manager").await.unwrap();
let keyspace = "testspace";
let password = b"testpass";
// Create session manager
let mut session = SessionManager::new(Vault::new(store));
// Create and unlock keyspace in one step
session.create_keyspace(keyspace, password, None).await.expect("create_keyspace via session");
// Add keypair using session API
let key_id = session.add_keypair(Some(KeyType::Secp256k1), Some(KeyMetadata { name: Some("main".to_string()), created_at: None, tags: None })).await.expect("add_keypair via session");
// Test add_keypair with metadata via SessionManager
let meta = KeyMetadata { name: Some("user1-key".to_string()), created_at: None, tags: Some(vec!["tag1".to_string()]) };
let key_id2 = session.add_keypair(Some(KeyType::Ed25519), Some(meta.clone())).await.expect("add_keypair via session");
// List keypairs and check metadata
let keypairs = session.list_keypairs().expect("list_keypairs");
assert!(keypairs.iter().any(|k| k.id == key_id2 && k.metadata.as_ref().unwrap().name.as_deref() == Some("user1-key")), "metadata name should be present");
}