server: kde plasma prompter support

going to be part of the upcoming Plasma 6.6 release

Author: hsitter

server/Cargo.toml

@@ -36,7 +36,10 @@ zbus = { workspace = true, features = ["p2p"] }
 zeroize.workspace = true
 
 [features]
-default = ["native_crypto"]
+default = ["gnome_native_crypto", "plasma"]
+gnome = []
+gnome_native_crypto = ["gnome", "native_crypto"]
+gnome_openssl_crypto = ["gnome", "openssl_crypto"]
 native_crypto = [
     "dep:hkdf",
     "dep:sha2",
@@ -46,6 +49,7 @@ openssl_crypto = [
     "dep:openssl",
     "oo7/openssl_crypto"
 ]
+plasma = []
 
 [dev-dependencies]
 serial_test = "3.3"

server/src/collection/tests.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use oo7::dbus;
 use tokio_stream::StreamExt;
 
-use crate::tests::TestServiceSetup;
+use crate::tests::{TestServiceSetup, prompters};
 
 #[tokio::test]
 async fn create_item_plain() -> Result<(), Box<dyn std::error::Error>> {
@@ -547,162 +547,182 @@ async fn collection_deleted_signal() -> Result<(), Box<dyn std::error::Error>> {
 
 #[tokio::test]
 async fn create_item_in_locked_collection() -> Result<(), Box<dyn std::error::Error>> {
-    let setup = TestServiceSetup::plain_session(true).await?;
-
-    let collection = setup
-        .server
-        .collection_from_path(setup.collections[0].inner().path())
-        .await
-        .expect("Collection should exist");
-    collection
-        .set_locked(true, setup.keyring_secret.clone())
-        .await?;
-
-    assert!(
-        setup.collections[0].is_locked().await?,
-        "Collection should be locked"
-    );
-
-    let secret = oo7::Secret::text("test-password");
-    let dbus_secret = dbus::api::DBusSecret::new(Arc::clone(&setup.session), secret.clone());
-
-    let item = setup.collections[0]
-        .create_item(
-            "Test Item",
-            &[("app", "test"), ("type", "password")],
-            &dbus_secret,
-            false,
-            None,
-        )
-        .await?;
-
-    assert!(
-        !setup.collections[0].is_locked().await?,
-        "Collection should be unlocked after prompt"
-    );
-
-    let items = setup.collections[0].items().await?;
-    assert_eq!(items.len(), 1, "Collection should have one item");
-    assert_eq!(
-        items[0].inner().path(),
-        item.inner().path(),
-        "Created item should be in the collection"
-    );
-
-    let label = item.label().await?;
-    assert_eq!(label, "Test Item", "Item should have correct label");
-
-    let attributes = item.attributes().await?;
-    assert_eq!(attributes.get("app"), Some(&"test".to_string()));
-    assert_eq!(attributes.get("type"), Some(&"password".to_string()));
-
-    let retrieved_secret = item.secret(&setup.session).await?;
-    assert_eq!(retrieved_secret.value(), secret.as_bytes());
+    for prompt_activator in prompters().await {
+        prompt_activator.activate();
+
+        let setup = TestServiceSetup::plain_session(true).await?;
+
+        let collection = setup
+            .server
+            .collection_from_path(setup.collections[0].inner().path())
+            .await
+            .expect("Collection should exist");
+        collection
+            .set_locked(true, setup.keyring_secret.clone())
+            .await?;
+
+        assert!(
+            setup.collections[0].is_locked().await?,
+            "Collection should be locked"
+        );
+
+        let secret = oo7::Secret::text("test-password");
+        let dbus_secret = dbus::api::DBusSecret::new(Arc::clone(&setup.session), secret.clone());
+
+        let item = setup.collections[0]
+            .create_item(
+                "Test Item",
+                &[("app", "test"), ("type", "password")],
+                &dbus_secret,
+                false,
+                None,
+            )
+            .await?;
+
+        assert!(
+            !setup.collections[0].is_locked().await?,
+            "Collection should be unlocked after prompt"
+        );
+
+        let items = setup.collections[0].items().await?;
+        assert_eq!(items.len(), 1, "Collection should have one item");
+        assert_eq!(
+            items[0].inner().path(),
+            item.inner().path(),
+            "Created item should be in the collection"
+        );
+
+        let label = item.label().await?;
+        assert_eq!(label, "Test Item", "Item should have correct label");
+
+        let attributes = item.attributes().await?;
+        assert_eq!(attributes.get("app"), Some(&"test".to_string()));
+        assert_eq!(attributes.get("type"), Some(&"password".to_string()));
+
+        let retrieved_secret = item.secret(&setup.session).await?;
+        assert_eq!(retrieved_secret.value(), secret.as_bytes());
+    }
 
     Ok(())
 }
 
 #[tokio::test]
 async fn delete_locked_collection_with_prompt() -> Result<(), Box<dyn std::error::Error>> {
-    let setup = TestServiceSetup::plain_session(true).await?;
-    let default_collection = setup.default_collection().await?;
-
-    let collection = setup
-        .server
-        .collection_from_path(default_collection.inner().path())
-        .await
-        .expect("Collection should exist");
-    collection
-        .set_locked(true, setup.keyring_secret.clone())
-        .await?;
-
-    assert!(
-        default_collection.is_locked().await?,
-        "Collection should be locked"
-    );
-
-    let collection_path = default_collection.inner().path().to_owned();
-
-    // Get initial collection count
-    let collections_before = setup.service_api.collections().await?;
-    let initial_count = collections_before.len();
-
-    // Delete the locked collection
-    default_collection.delete(None).await?;
-
-    // Give the system a moment to process the deletion
-    tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
-
-    // Verify collection was deleted
-    let collections_after = setup.service_api.collections().await?;
-    assert_eq!(
-        collections_after.len(),
-        initial_count - 1,
-        "Collection should be deleted after prompt"
-    );
-
-    // Verify the specific collection is not in the list
-    let collection_paths: Vec<_> = collections_after
-        .iter()
-        .map(|c| c.inner().path().as_str())
-        .collect();
-    assert!(
-        !collection_paths.contains(&collection_path.as_str()),
-        "Deleted collection should not be in service collections list"
-    );
+    for prompt_activator in prompters().await {
+        prompt_activator.activate();
+
+        let setup = TestServiceSetup::plain_session(true).await?;
+        let default_collection = setup.default_collection().await?;
+
+        let collection = setup
+            .server
+            .collection_from_path(default_collection.inner().path())
+            .await
+            .expect("Collection should exist");
+        collection
+            .set_locked(true, setup.keyring_secret.clone())
+            .await?;
+
+        assert!(
+            default_collection.is_locked().await?,
+            "Collection should be locked"
+        );
+
+        let collection_path = default_collection.inner().path().to_owned();
+
+        // Get initial collection count
+        let collections_before = setup.service_api.collections().await?;
+        let initial_count = collections_before.len();
+
+        // Delete the locked collection
+        default_collection.delete(None).await?;
+
+        // Give the system a moment to process the deletion
+        tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
+
+        // Verify collection was deleted
+        let collections_after = setup.service_api.collections().await?;
+        assert_eq!(
+            collections_after.len(),
+            initial_count - 1,
+            "Collection should be deleted after prompt"
+        );
+
+        // Verify the specific collection is not in the list
+        let collection_paths: Vec<_> = collections_after
+            .iter()
+            .map(|c| c.inner().path().as_str())
+            .collect();
+        assert!(
+            !collection_paths.contains(&collection_path.as_str()),
+            "Deleted collection should not be in service collections list"
+        );
+    }
 
     Ok(())
 }
 
 #[tokio::test]
 async fn unlock_retry() -> Result<(), Box<dyn std::error::Error>> {
-    let setup = TestServiceSetup::plain_session(true).await?;
-    let default_collection = setup.default_collection().await?;
-
-    let secret = oo7::Secret::text("test-secret-data");
-    let dbus_secret = dbus::api::DBusSecret::new(Arc::clone(&setup.session), secret);
-    default_collection
-        .create_item("Test Item", &[("app", "test")], &dbus_secret, false, None)
-        .await?;
-
-    let collection = setup
-        .server
-        .collection_from_path(default_collection.inner().path())
-        .await
-        .expect("Collection should exist");
-    collection
-        .set_locked(true, setup.keyring_secret.clone())
-        .await?;
-
-    assert!(
-        default_collection.is_locked().await?,
-        "Collection should be locked"
-    );
-
-    setup
-        .mock_prompter
-        .set_password_queue(vec![
-            oo7::Secret::from("wrong-password"),
-            oo7::Secret::from("wrong-password2"),
-            oo7::Secret::from("test-password-long-enough"),
-        ])
-        .await;
-
-    let unlocked = setup
-        .service_api
-        .unlock(&[default_collection.inner().path()], None)
-        .await?;
-
-    assert_eq!(unlocked.len(), 1, "Should have unlocked 1 collection");
-    assert_eq!(
-        unlocked[0].as_str(),
-        default_collection.inner().path().as_str(),
-        "Should return the collection path"
-    );
-    assert!(
-        !default_collection.is_locked().await?,
-        "Collection should be unlocked after retry with correct password"
-    );
+    for prompt_activator in prompters().await {
+        prompt_activator.activate();
+
+        let setup = TestServiceSetup::plain_session(true).await?;
+        let default_collection = setup.default_collection().await?;
+
+        let secret = oo7::Secret::text("test-secret-data");
+        let dbus_secret = dbus::api::DBusSecret::new(Arc::clone(&setup.session), secret);
+        default_collection
+            .create_item("Test Item", &[("app", "test")], &dbus_secret, false, None)
+            .await?;
+
+        let collection = setup
+            .server
+            .collection_from_path(default_collection.inner().path())
+            .await
+            .expect("Collection should exist");
+        collection
+            .set_locked(true, setup.keyring_secret.clone())
+            .await?;
+
+        assert!(
+            default_collection.is_locked().await?,
+            "Collection should be locked"
+        );
+
+        setup
+            .mock_prompter
+            .set_password_queue(vec![
+                oo7::Secret::from("wrong-password"),
+                oo7::Secret::from("wrong-password2"),
+                oo7::Secret::from("test-password-long-enough"),
+            ])
+            .await;
+        setup
+            .mock_prompter_plasma
+            .set_password_queue(vec![
+                oo7::Secret::from("wrong-password"),
+                oo7::Secret::from("wrong-password2"),
+                oo7::Secret::from("test-password-long-enough"),
+            ])
+            .await;
+
+        let unlocked = setup
+            .service_api
+            .unlock(&[default_collection.inner().path()], None)
+            .await?;
+
+        assert_eq!(unlocked.len(), 1, "Should have unlocked 1 collection");
+        assert_eq!(
+            unlocked[0].as_str(),
+            default_collection.inner().path().as_str(),
+            "Should return the collection path"
+        );
+        assert!(
+            !default_collection.is_locked().await?,
+            "Collection should be unlocked after retry with correct password"
+        );
+    }
 
     Ok(())
 }