From 27c5edf5543d5cc808a23aa847c2028e5d20af75 Mon Sep 17 00:00:00 2001
From: Paul Butler <paul@driftingin.space>
Date: Sun, 1 Sep 2024 11:52:10 -0400
Subject: [PATCH] tests pass

---
 aper/src/aper.rs       |  5 +----
 aper/src/connection.rs |  2 --
 aper/src/store.rs      | 16 +++++++++-------
 aper/tests/listener.rs | 11 ++---------
 4 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/aper/src/aper.rs b/aper/src/aper.rs
index bc831e6..cde114a 100644
--- a/aper/src/aper.rs
+++ b/aper/src/aper.rs
@@ -135,12 +135,8 @@ impl<A: Aper> AperClient<A> {
         self.store.pop_overlay();
         self.verified_server_version = server_version;
 
-        println!("mutate called; before: {:?}", self.store);
-
         self.store.mutate(mutations);
 
-        println!("mutate called; after: {:?}", self.store);
-
         // push new speculative overlay
         self.store.push_overlay();
 
@@ -167,6 +163,7 @@ impl<A: Aper> AperClient<A> {
         for speculative_intent in self.intent_stack.iter() {
             // push a working overlay
             self.store.push_overlay();
+
             let mut sm = A::attach(self.store.handle());
 
             if sm.apply(&speculative_intent.intent).is_err() {
diff --git a/aper/src/connection.rs b/aper/src/connection.rs
index ada412f..75e2923 100644
--- a/aper/src/connection.rs
+++ b/aper/src/connection.rs
@@ -92,8 +92,6 @@ impl<A: Aper> ClientConnection<A> {
     }
 
     pub fn receive(&mut self, message: &MessageToClient) {
-        println!("Received message: {:?}", message);
-
         match &message.message {
             MessageToClientType::Apply {
                 mutations,
diff --git a/aper/src/store.rs b/aper/src/store.rs
index 5c6d27d..088d795 100644
--- a/aper/src/store.rs
+++ b/aper/src/store.rs
@@ -20,16 +20,16 @@ pub enum PrefixMap {
 }
 
 impl PrefixMap {
-    fn get(&self, key: &Bytes) -> Option<Bytes> {
+    fn get(&self, key: &Bytes) -> Option<PrefixMapValue> {
         match self {
             PrefixMap::Children(children) => {
-                if let Some(PrefixMapValue::Value(value)) = children.get(key) {
+                if let Some(value) = children.get(key) {
                     Some(value.clone())
                 } else {
                     None
                 }
             }
-            PrefixMap::DeletedPrefixMap => None,
+            PrefixMap::DeletedPrefixMap => Some(PrefixMapValue::Deleted),
         }
     }
 
@@ -212,13 +212,15 @@ impl Store {
 
         for layer in inner.layers.iter().rev() {
             if let Some(map) = layer.layer.get(prefix) {
-                println!("yy {:?} {:?}", prefix, key);
-                return map.get(key);
+                if let Some(value) = map.get(key) {
+                    match value {
+                        PrefixMapValue::Value(value) => return Some(value.clone()),
+                        PrefixMapValue::Deleted => return None,
+                    }
+                }
             }
         }
 
-        println!("xx {:?} {:?}", prefix, key);
-
         None
     }
 
diff --git a/aper/tests/listener.rs b/aper/tests/listener.rs
index e28ba5f..fa56a07 100644
--- a/aper/tests/listener.rs
+++ b/aper/tests/listener.rs
@@ -133,10 +133,6 @@ impl Aper for LinkedFields {
     type Error = ();
 
     fn apply(&mut self, intent: &Self::Intent) -> Result<(), Self::Error> {
-        println!("apply: {:?}", intent);
-        println!("lhs: {:?}", self.lhs.get());
-        println!("rhs: {:?}", self.rhs.get());
-
         match intent {
             LinkedFieldIntent::SetLhs(value) => self.lhs.set(*value),
             LinkedFieldIntent::SetRhs(value) => self.rhs.set(*value),
@@ -169,13 +165,14 @@ fn test_mutate_listener_incidental() {
     assert_eq!(1, st.lhs.get());
     assert_eq!(1, st.sum.get());
 
+    client.mutate(&vec![], None, 1);
+
     assert!(lhs_recv.try_recv().is_ok());
     assert!(rhs_recv.try_recv().is_err());
     assert!(sum_recv.try_recv().is_ok());
 
     // now mutate the rhs, which should cause the sum to be recomputed
 
-    println!("mutating rhs");
     client.mutate(
         &vec![create_mutation(
             vec![b"rhs"],
@@ -187,10 +184,6 @@ fn test_mutate_listener_incidental() {
         None,
         1,
     );
-    println!("done mutating rhs");
-
-    // TODO: this should not cause a failure, but does?
-    // let st = client.state();
 
     assert_eq!(26, st.rhs.get());
     assert_eq!(27, st.sum.get());