Clear cache before verify on some low-level tests (#2044)

server/lib-macros/src/entry.rs

@@ -79,6 +79,8 @@ pub(crate) fn qs_test(_args: &TokenStream, item: TokenStream, with_init: bool) -
                 #test_fn(&test_server).await;
 
                 // Any needed teardown?
+                // Clear the cache before we verify.
+                assert!(test_server.clear_cache().await.is_ok());
                 // Make sure there are no errors.
                 let verifications = test_server.verify().await;
                 trace!("Verification result: {:?}", verifications);
@@ -172,6 +174,8 @@ pub(crate) fn qs_pair_test(_args: &TokenStream, item: TokenStream, with_init: bo
                 #test_fn(&server_a, &server_b).await;
 
                 // Any needed teardown?
+                assert!(server_a.clear_cache().await.is_ok());
+                assert!(server_b.clear_cache().await.is_ok());
                 // Make sure there are no errors.
                 let verifications_a = server_a.verify().await;
                 let verifications_b = server_b.verify().await;
@@ -263,6 +267,7 @@ pub(crate) fn idm_test(args: &TokenStream, item: TokenStream) -> TokenStream {
                 #test_fn(#test_fn_args).await;
 
                 // Any needed teardown?
+                // assert!(test_server.clear_cache().await.is_ok());
                 // Make sure there are no errors.
                 let mut idm_read_txn = test_server.proxy_read().await;
                 let verifications = idm_read_txn.qs_read.verify();

server/lib/src/be/idl_arc_sqlite.rs

@@ -565,6 +565,24 @@ impl<'a> IdlArcSqliteTransaction for IdlArcSqliteWriteTransaction<'a> {
 }
 
 impl<'a> IdlArcSqliteWriteTransaction<'a> {
+    #[cfg(debug_assertions)]
+    #[instrument(level = "debug", name = "idl_arc_sqlite::clear_cache", skip_all)]
+    pub fn clear_cache(&mut self) -> Result<(), OperationError> {
+        // I'm not sure rn if I want to reload these? If we reload these we kind of
+        // prevent verifications of the cached value working, but we also should
+        // clear these to check the db version of the value. Perhaps some extra
+        // dedicated testing needed?
+        /*
+         *self.op_ts_max = self.db.get_db_ts_max()?;
+         *self.allids = self.db.get_allids()?;
+         *self.maxid = self.get_id2entry_max_id()?;
+         */
+        self.entry_cache.clear();
+        self.idl_cache.clear();
+        self.name_cache.clear();
+        Ok(())
+    }
+
     #[instrument(level = "debug", name = "idl_arc_sqlite::commit", skip_all)]
     pub fn commit(self) -> Result<(), OperationError> {
         let IdlArcSqliteWriteTransaction {

server/lib/src/be/mod.rs

@@ -1792,6 +1792,11 @@ impl<'a> BackendWriteTransaction<'a> {
         self.set_db_index_version(0)
     }
 
+    #[cfg(debug_assertions)]
+    pub fn clear_cache(&mut self) -> Result<(), OperationError> {
+        self.get_idlayer().clear_cache()
+    }
+
     pub fn commit(self) -> Result<(), OperationError> {
         let BackendWriteTransaction {
             idlayer,

server/lib/src/server/mod.rs

@@ -1220,6 +1220,14 @@ impl QueryServer {
         }
     }
 
+    #[cfg(debug_assertions)]
+    pub async fn clear_cache(&self) -> Result<(), OperationError> {
+        let ct = duration_from_epoch_now();
+        let mut w_txn = self.write(ct).await;
+        w_txn.clear_cache()?;
+        w_txn.commit()
+    }
+
     pub async fn verify(&self) -> Vec<Result<(), ConsistencyError>> {
         let mut r_txn = self.read().await;
         r_txn.verify()
@@ -1600,6 +1608,12 @@ impl<'a> QueryServerWriteTransaction<'a> {
         Ok(())
     }
 
+    #[cfg(debug_assertions)]
+    #[instrument(level = "debug", skip_all)]
+    pub fn clear_cache(&mut self) -> Result<(), OperationError> {
+        self.be_txn.clear_cache()
+    }
+
     #[instrument(level = "info", skip_all)]
     pub fn commit(mut self) -> Result<(), OperationError> {
         self.reload()?;