feat(torture):reverted changeset on previous state

Make sure that any reverted changes did not alter
already present values. To do this, compare them with
the values of the previous state maintained by the supervisor.

torture/src/agent.rs

@@ -111,7 +111,6 @@ pub async fn run(input: UnixStream) -> Result<()> {
                     .await?;
             }
             ToAgent::Query(key) => {
-                trace!("query: {}", hex::encode(key));
                 let value = agent.query(key)?;
                 stream
                     .send(Envelope {

torture/src/supervisor/comms.rs

@@ -88,7 +88,6 @@ impl RequestResponse {
     // Requests the value of the key from the agent.
     #[allow(dead_code)]
     pub async fn send_request_query(&self, key: message::Key) -> anyhow::Result<Option<Vec<u8>>> {
-        trace!(key = hex::encode(&key), "sending storage query");
         match self
             .send_request(crate::message::ToAgent::Query(key))
             .await?

torture/src/supervisor/workload.rs

@@ -404,16 +404,31 @@ impl Workload {
         // is equal to its previous state and that each new key is not avaible.
         for change in changeset {
             match change {
-                KeyValueChange::Insert(key, value)
-                    if rr.send_request_query(*key).await?.as_ref() == Some(value) =>
-                {
-                    return Err(anyhow::anyhow!("Inserted item should be reverted"));
+                KeyValueChange::Insert(key, _value) => {
+                    // The current value must be equal to the previous one.
+                    let current_value = rr.send_request_query(*key).await?;
+                    match self.state.committed.state.get(key) {
+                        None | Some(None) if current_value.is_some() => {
+                            return Err(anyhow::anyhow!("New inserted item should not be present"));
+                        }
+                        Some(prev_value) if current_value != *prev_value => {
+                            return Err(anyhow::anyhow!(
+                                "Modified item should be reverted to previous state"
+                            ));
+                        }
+                        _ => (),
+                    }
                 }
-                // This holds as long as we are sure that every deletions is done on present keys.
-                KeyValueChange::Delete(key) if rr.send_request_query(*key).await?.is_none() => {
-                    return Err(anyhow::anyhow!("Deletion should have been reverted"));
+                KeyValueChange::Delete(key) => {
+                    // UNWRAP: Non existing keys are not deleted.
+                    let prev_value = self.state.committed.state.get(key).unwrap();
+                    assert!(prev_value.is_some());
+                    if rr.send_request_query(*key).await?.as_ref() != prev_value.as_ref() {
+                        return Err(anyhow::anyhow!(
+                            "Deleted item should be reverted to previous state"
+                        ));
+                    }
                 }
-                _ => (),
             }
         }
         Ok(())