1 files changed, 30 insertions, 25 deletions
diff --git a/src/test/webpush.rs b/src/test/webpush.rs
index 96fa843..55caf19 100644
--- a/src/test/webpush.rs
+++ b/src/test/webpush.rs
@@ -2,7 +2,7 @@ use std::{
     any::Any,
     collections::{HashMap, HashSet},
     mem,
-    sync::{Arc, Mutex},
+    sync::{Arc, Mutex, MutexGuard},
 };
 
 use web_push::{PartialVapidSignatureBuilder, SubscriptionInfo, WebPushError};
@@ -10,59 +10,64 @@ use web_push::{PartialVapidSignatureBuilder, SubscriptionInfo, WebPushError};
 use crate::{error::failed::Failed, push::Publish};
 
 #[derive(Clone)]
-pub struct Client {
-    sent: Arc<Mutex<Vec<Publication>>>,
-    failures: Arc<Mutex<HashMap<SubscriptionInfo, WebPushError>>>,
+pub struct Client(Arc<Mutex<ClientInner>>);
+
+#[derive(Default)]
+struct ClientInner {
+    sent: Vec<Publication>,
+    planned_failures: HashMap<SubscriptionInfo, WebPushError>,
 }
 
 impl Client {
     pub fn new() -> Self {
-        Self {
-            sent: Arc::default(),
-            failures: Arc::default(),
-        }
+        Self(Arc::default())
+    }
+
+    fn inner(&self) -> MutexGuard<'_, ClientInner> {
+        self.0.lock().unwrap()
     }
 
     // Clears the list of sent messages (for all clones of this Client) when called, because we
     // can't clone `Publications`s, so we either need to move them or try to reconstruct them.
     pub fn sent(&self) -> Vec<Publication> {
-        let mut sent = self.sent.lock().unwrap();
-        mem::take(&mut sent)
+        let sent = &mut self.inner().sent;
+        mem::take(sent)
     }
 
     pub fn fail_next(&self, subscription_info: &SubscriptionInfo, err: WebPushError) {
-        let mut failures = self.failures.lock().unwrap();
-        failures.insert(subscription_info.clone(), err);
+        let planned_failures = &mut self.inner().planned_failures;
+        planned_failures.insert(subscription_info.clone(), err);
     }
 }
 
+#[async_trait::async_trait]
 impl Publish for Client {
-    async fn publish<M>(
+    async fn publish<'s, M>(
         &self,
         message: M,
-        _: PartialVapidSignatureBuilder,
-        subscriptions: impl IntoIterator<Item = SubscriptionInfo> + Send,
-    ) -> Result<Vec<(SubscriptionInfo, WebPushError)>, Failed>
+        _: &PartialVapidSignatureBuilder,
+        subscriptions: impl IntoIterator<Item = &'s SubscriptionInfo> + Send,
+    ) -> Result<Vec<(&'s SubscriptionInfo, WebPushError)>, Failed>
     where
         M: Send + 'static,
     {
+        let mut inner = self.inner();
         let message: Box<dyn Any + Send> = Box::new(message);
-        let subscriptions = subscriptions.into_iter().collect();
 
+        let mut recipients = HashSet::new();
         let mut failures = Vec::new();
-
-        let mut planned_failures = self.failures.lock().unwrap();
-        for subscription in &subscriptions {
-            if let Some(err) = planned_failures.remove(subscription) {
-                failures.push((subscription.clone(), err));
+        for subscription in subscriptions {
+            recipients.insert(subscription.clone());
+            if let Some(err) = inner.planned_failures.remove(subscription) {
+                failures.push((subscription, err));
             }
         }
 
         let publication = Publication {
             message,
-            subscriptions,
+            recipients,
         };
-        self.sent.lock().unwrap().push(publication);
+        inner.sent.push(publication);
 
         Ok(failures)
     }
@@ -71,7 +76,7 @@ impl Publish for Client {
 #[derive(Debug)]
 pub struct Publication {
     pub message: Box<dyn Any + Send>,
-    pub subscriptions: HashSet<SubscriptionInfo>,
+    pub recipients: HashSet<SubscriptionInfo>,
 }
 
 impl Publication {