1 files changed, 79 insertions, 1 deletions

diff --git a/src/suite.rs b/src/suite.rs
index e900330..b4e8abb 100644
--- a/src/suite.rs
+++ b/src/suite.rs
@@ -5,7 +5,9 @@ use crate::result::{Measurement, OpMeasurements, Operation};
 use crate::server::{ObnamServer, ObnamServerError};
 use crate::specification::{Create, FileCount};
 use crate::step::Step;
-use log::{debug, info};
+use crate::summain::{summain, SummainError};
+use log::{debug, error, info};
+use std::collections::HashMap;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 use std::time::Instant;
@@ -47,6 +49,22 @@ pub enum SuiteError {
     /// Error managing an Obnam server.
     #[error(transparent)]
     Server(#[from] ObnamServerError),
+
+    /// Suite already has a manifest with a given id.
+    #[error("Suite already has manifest {0}: this is a bug")]
+    ManifestExists(usize),
+
+    /// Suite doesn't have a manifest with a given id.
+    #[error("Suite doesn't have a manifest {0}: this is a bug")]
+    ManifestMissing(usize),
+
+    /// Manifests are not identical.
+    #[error("Manifests {0} and {1} are not identical, as expected")]
+    ManifestsDiffer(usize, usize),
+
+    /// Error running summain.
+    #[error(transparent)]
+    Summain(SummainError),
 }
 
 impl Suite {
@@ -98,6 +116,21 @@ impl Suite {
                 assert!(self.benchmark.is_some());
                 self.benchmark.as_mut().unwrap().restore(*x)?
             }
+            Step::ManifestLive(id) => {
+                assert!(self.benchmark.is_some());
+                self.benchmark.as_mut().unwrap().manifest_live(*id)?
+            }
+            Step::ManifestRestored(id) => {
+                assert!(self.benchmark.is_some());
+                self.benchmark.as_mut().unwrap().manifest_restored(*id)?
+            }
+            Step::CompareManifests(first, second) => {
+                assert!(self.benchmark.is_some());
+                self.benchmark
+                    .as_mut()
+                    .unwrap()
+                    .compare_manifests(*first, *second)?
+            }
         };
 
         let t = std::time::Duration::from_millis(10);
@@ -115,6 +148,7 @@ struct Benchmark {
     client: ObnamClient,
     server: ObnamServer,
     live: TempDir,
+    manifests: HashMap<usize, String>,
 }
 
 impl Benchmark {
@@ -127,6 +161,7 @@ impl Benchmark {
             client,
             server,
             live,
+            manifests: HashMap::new(),
         })
     }
 
@@ -194,6 +229,49 @@ impl Benchmark {
         info!("restoring backup {} in benchmark {}", n, self.name());
         Ok(OpMeasurements::new(self.name(), Operation::Restore))
     }
+
+    fn manifest_live(&mut self, id: usize) -> Result<OpMeasurements, SuiteError> {
+        info!("make manifest {} of current test data", id);
+        if self.manifests.contains_key(&id) {
+            return Err(SuiteError::ManifestExists(id));
+        }
+        let m = summain(self.live.path()).map_err(SuiteError::Summain)?;
+        self.manifests.insert(id, m);
+        Ok(OpMeasurements::new(self.name(), Operation::ManifestLive))
+    }
+
+    fn manifest_restored(&mut self, id: usize) -> Result<OpMeasurements, SuiteError> {
+        info!("make manifest {} of latest restored data", id);
+        if self.manifests.contains_key(&id) {
+            return Err(SuiteError::ManifestExists(id));
+        }
+        self.manifests.insert(id, "dummy".to_string());
+        Ok(OpMeasurements::new(self.name(), Operation::ManifestLive))
+    }
+
+    fn compare_manifests(
+        &mut self,
+        first: usize,
+        second: usize,
+    ) -> Result<OpMeasurements, SuiteError> {
+        info!("compare manifests {} and {}", first, second);
+        let m1 = self.manifest(first)?;
+        let m2 = self.manifest(second)?;
+        if m1 != m2 {
+            error!("first manifest:\n{}", m1);
+            error!("second manifest:\n{}", m2);
+            return Err(SuiteError::ManifestsDiffer(first, second));
+        }
+        Ok(OpMeasurements::new(self.name(), Operation::ManifestLive))
+    }
+
+    fn manifest(&self, id: usize) -> Result<String, SuiteError> {
+        if let Some(m) = self.manifests.get(&id) {
+            Ok(m.clone())
+        } else {
+            Err(SuiteError::ManifestMissing(id))
+        }
+    }
 }
 
 #[derive(Debug, Default)]