Skip to content

Commit c4fa5fe

Browse files
bilelmoussaouibilelmoussaoui
committed
server/tests: Avoid too many unwraps
1 parent 0cf9af5 commit c4fa5fe

5 files changed

Lines changed: 200 additions & 186 deletions

File tree

‎server/src/collection.rs‎

Lines changed: 70 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -346,154 +346,170 @@ mod tests {
346346
use super::*;
347347

348348
#[tokio::test]
349-
async fn create_item_plain() {
350-
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await;
349+
async fn create_item_plain() -> Result<(), Box<dyn std::error::Error>> {
350+
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await?;
351351

352352
let _server = Service::run_with_connection(
353353
server_conn,
354354
Some(oo7::Secret::from("test-password-long-enough")),
355355
)
356-
.await
357-
.unwrap();
356+
.await?;
358357

359358
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
360359

361-
let service_api = dbus::api::Service::new(&client_conn).await.unwrap();
360+
let service_api = dbus::api::Service::new(&client_conn).await?;
362361

363362
// Open plain session
364-
let (_aes_key, session) = service_api.open_session(None).await.unwrap();
363+
let (_aes_key, session) = service_api.open_session(None).await?;
365364

366365
// Get default collection
367-
let collections = service_api.collections().await.unwrap();
366+
let collections = service_api.collections().await?;
368367

369368
// Create an item using the proper API
370369
let secret = oo7::Secret::text("my-secret-password");
371-
let attributes = &[("application", "test-app"), ("type", "password")];
372370
let dbus_secret = dbus::api::DBusSecret::new(Arc::new(session), secret.clone());
373371

374372
let item = collections[0]
375-
.create_item("Test Item", attributes, &dbus_secret, false, None)
376-
.await
377-
.unwrap();
373+
.create_item(
374+
"Test Item",
375+
&[("application", "test-app"), ("type", "password")],
376+
&dbus_secret,
377+
false,
378+
None,
379+
)
380+
.await?;
378381

379382
// Verify item exists in collection
380-
let items = collections[0].items().await.unwrap();
383+
let items = collections[0].items().await?;
381384
assert_eq!(items.len(), 1, "Collection should have one item");
382385
assert_eq!(items[0].inner().path(), item.inner().path());
383386

384387
// Verify item label
385-
let label = item.label().await.unwrap();
388+
let label = item.label().await?;
386389
assert_eq!(label, "Test Item");
390+
391+
Ok(())
387392
}
388393

389394
#[tokio::test]
390-
async fn create_item_encrypted() {
391-
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await;
395+
async fn create_item_encrypted() -> Result<(), Box<dyn std::error::Error>> {
396+
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await?;
392397

393398
let _server = Service::run_with_connection(
394399
server_conn,
395400
Some(oo7::Secret::from("test-password-long-enough")),
396401
)
397-
.await
398-
.unwrap();
402+
.await?;
399403

400404
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
401405

402-
let service_api = dbus::api::Service::new(&client_conn).await.unwrap();
406+
let service_api = dbus::api::Service::new(&client_conn).await?;
403407

404408
// Open encrypted session
405-
let client_private_key = oo7::Key::generate_private_key().unwrap();
406-
let client_public_key = oo7::Key::generate_public_key(&client_private_key).unwrap();
409+
let client_private_key = oo7::Key::generate_private_key()?;
410+
let client_public_key = oo7::Key::generate_public_key(&client_private_key)?;
407411

408-
let (server_public_key_opt, session) = service_api
409-
.open_session(Some(client_public_key))
410-
.await
411-
.unwrap();
412+
let (server_public_key_opt, session) =
413+
service_api.open_session(Some(client_public_key)).await?;
412414

413415
let server_public_key = server_public_key_opt.unwrap();
414-
let aes_key = oo7::Key::generate_aes_key(&client_private_key, &server_public_key).unwrap();
416+
let aes_key = oo7::Key::generate_aes_key(&client_private_key, &server_public_key)?;
415417

416418
// Get default collection
417-
let collections = service_api.collections().await.unwrap();
419+
let collections = service_api.collections().await?;
418420

419421
// Create an encrypted item using the proper API
420422
let secret = oo7::Secret::text("my-encrypted-secret");
421-
let attributes = &[("application", "test-app"), ("type", "encrypted-password")];
422423
let dbus_secret =
423-
dbus::api::DBusSecret::new_encrypted(Arc::new(session), secret, &aes_key).unwrap();
424+
dbus::api::DBusSecret::new_encrypted(Arc::new(session), secret, &aes_key)?;
424425

425426
let item = collections[0]
426-
.create_item("Test Encrypted Item", attributes, &dbus_secret, false, None)
427-
.await
428-
.unwrap();
427+
.create_item(
428+
"Test Encrypted Item",
429+
&[("application", "test-app"), ("type", "encrypted-password")],
430+
&dbus_secret,
431+
false,
432+
None,
433+
)
434+
.await?;
429435

430436
// Verify item exists
431-
let items = collections[0].items().await.unwrap();
437+
let items = collections[0].items().await?;
432438
assert_eq!(items.len(), 1, "Collection should have one item");
433439
assert_eq!(items[0].inner().path(), item.inner().path());
440+
441+
Ok(())
434442
}
435443

436444
#[tokio::test]
437-
async fn search_items_after_creation() {
438-
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await;
445+
async fn search_items_after_creation() -> Result<(), Box<dyn std::error::Error>> {
446+
let (server_conn, client_conn) = crate::tests::create_p2p_connection().await?;
439447

440448
let _server = Service::run_with_connection(
441449
server_conn,
442450
Some(oo7::Secret::from("test-password-long-enough")),
443451
)
444-
.await
445-
.unwrap();
452+
.await?;
446453

447454
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
448455

449-
let service_api = dbus::api::Service::new(&client_conn).await.unwrap();
450-
let (_aes_key, session) = service_api.open_session(None).await.unwrap();
456+
let service_api = dbus::api::Service::new(&client_conn).await?;
457+
let (_aes_key, session) = service_api.open_session(None).await?;
451458
let session = Arc::new(session);
452459

453-
let collections = service_api.collections().await.unwrap();
460+
let collections = service_api.collections().await?;
454461

455462
// Create two items with different attributes
456463
let secret1 = oo7::Secret::text("password1");
457-
let attributes1 = &[("application", "firefox"), ("username", "user1")];
458464
let dbus_secret1 = dbus::api::DBusSecret::new(Arc::clone(&session), secret1);
459465

460466
collections[0]
461-
.create_item("Firefox Password", attributes1, &dbus_secret1, false, None)
462-
.await
463-
.unwrap();
467+
.create_item(
468+
"Firefox Password",
469+
&[("application", "firefox"), ("username", "user1")],
470+
&dbus_secret1,
471+
false,
472+
None,
473+
)
474+
.await?;
464475

465476
let secret2 = oo7::Secret::text("password2");
466-
let attributes2 = &[("application", "chrome"), ("username", "user2")];
467477
let dbus_secret2 = dbus::api::DBusSecret::new(Arc::clone(&session), secret2);
468478

469479
collections[0]
470-
.create_item("Chrome Password", attributes2, &dbus_secret2, false, None)
471-
.await
472-
.unwrap();
480+
.create_item(
481+
"Chrome Password",
482+
&[("application", "chrome"), ("username", "user2")],
483+
&dbus_secret2,
484+
false,
485+
None,
486+
)
487+
.await?;
473488

474489
// Search for firefox item
475490
let firefox_attrs = &[("application", "firefox")];
476-
let firefox_items = collections[0].search_items(firefox_attrs).await.unwrap();
491+
let firefox_items = collections[0].search_items(firefox_attrs).await?;
477492

478493
assert_eq!(firefox_items.len(), 1, "Should find one firefox item");
479494

480495
// Search for chrome item
481-
let chrome_attrs = &[("application", "chrome")];
482-
let chrome_items = collections[0].search_items(chrome_attrs).await.unwrap();
496+
let chrome_items = collections[0]
497+
.search_items(&[("application", "chrome")])
498+
.await?;
483499

484500
assert_eq!(chrome_items.len(), 1, "Should find one chrome item");
485501

486502
// Search for non-existent item
487-
let nonexistent_attrs = &[("application", "nonexistent")];
488503
let nonexistent_items = collections[0]
489-
.search_items(nonexistent_attrs)
490-
.await
491-
.unwrap();
504+
.search_items(&[("application", "nonexistent")])
505+
.await?;
492506

493507
assert_eq!(
494508
nonexistent_items.len(),
495509
0,
496510
"Should find no nonexistent items"
497511
);
512+
513+
Ok(())
498514
}
499515
}

‎server/src/error.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,8 @@ pub enum Error {
2020
Capability(capability::Error),
2121
}
2222

23+
impl std::error::Error for Error {}
24+
2325
impl From<zbus::Error> for Error {
2426
fn from(err: zbus::Error) -> Self {
2527
Self::Zbus(err)

0 commit comments

Comments
 (0)