test: improve integration coverage

Cargo.toml

@@ -44,6 +44,7 @@ tempfile = "3.9.0"
 assert_cmd = "2.0.13"
 predicates = "3.0.4"
 pretty_assertions = "1.4.0"
+rand = "0.8.5"
 
 [build-dependencies]
 built = "0.7.1"

src/project.rs

@@ -50,7 +50,7 @@ impl Project {
         path: PathBuf,
         facts: Box<dyn ProjectFactProvider>,
     ) -> anyhow::Result<Self> {
-        let config = Self::load_project_config(&path.join("./sprout.yaml"))?;
+        let config = Self::load_project_config(&path.join("sprout.yaml"))?;
 
         Ok(Self {
             unique_hash: facts.generate_unique_hash()?,
@@ -67,7 +67,7 @@ impl Project {
         path: PathBuf,
         facts: Box<dyn ProjectFactProvider>,
     ) -> anyhow::Result<Self> {
-        if path.join("./sprout.yaml").exists() {
+        if path.join("sprout.yaml").exists() {
             return Err(anyhow::anyhow!("A sprout.yaml already exists!"));
         }
 
@@ -79,6 +79,7 @@ impl Project {
         if let Ok(installed) = facts.is_wordpress_installed() {
             if installed {
                 if let Ok(detected_uploads_path) = facts.get_uploads_dir() {
+                    println!("{:?}, {:?}", path, detected_uploads_path);
                     uploads_path = PathBuf::from(detected_uploads_path)
                         .strip_prefix(&path)?
                         .to_path_buf();
@@ -94,7 +95,7 @@ impl Project {
             repo: sprout_config.default_repo,
         };
 
-        fs::write(path.join("./sprout.yaml"), serde_yaml::to_string(&config)?)?;
+        fs::write(path.join("sprout.yaml"), serde_yaml::to_string(&config)?)?;
 
         Project::new(engine, path, facts)
     }
@@ -164,7 +165,7 @@ impl Project {
         self.config.branch = branch;
 
         fs::write(
-            self.path.join("./sprout.yaml"),
+            self.path.join("sprout.yaml"),
             serde_yaml::to_string(&self.config)?,
         )?;
 
@@ -203,7 +204,7 @@ impl Project {
         let streamer_opts = LsOptions::default();
         let ls = rustic_repo.ls(&uploads_node, &streamer_opts)?;
 
-        let destination = fs::canonicalize(&self.config.uploads_path)?; // restore to this destination dir
+        let destination = fs::canonicalize(&self.path)?.join(&self.config.uploads_path); // restore to this destination dir
         let create = true; // create destination dir, if it doesn't exist
         let dest = LocalDestination::new(
             &destination.to_string_lossy(),

src/repo.rs

@@ -93,7 +93,7 @@ impl ProjectRepository {
 
         let source = PathList::from_string(&db_filename.to_string_lossy())?;
 
-        let snap = SnapshotOptions::default()
+        let mut snap = SnapshotOptions::default()
             .add_tags(
                 format!(
                     "sprt_obj:database,sprt_uniq:{},sprt_branch:{}",
@@ -106,9 +106,10 @@ impl ProjectRepository {
                 .as_str(),
             )?
             .host(self.project.config.name.to_owned())
-            .command(format!("sprout-{}", PKG_VERSION))
             .to_snapshot()?;
 
+        snap.program_version = format!("sprout-{}", PKG_VERSION);
+
         // Create snapshot
         let snap = repo.backup(&backup_opts, &source, snap)?;
 
@@ -139,15 +140,15 @@ impl ProjectRepository {
 
         let repo = repo.clone().open()?.to_indexed_ids()?;
 
-        if !self.project.config.uploads_path.exists() {
-            fs::create_dir_all(&self.project.config.uploads_path)?;
+        let resolved_uploads_path =
+            fs::canonicalize(&self.project.path)?.join(&self.project.config.uploads_path);
+
+        if !resolved_uploads_path.exists() {
+            fs::create_dir_all(&resolved_uploads_path)?;
         }
 
-        let source = PathList::from_string(
-            &fs::canonicalize(&self.project.config.uploads_path)
-                .unwrap()
-                .to_string_lossy(),
-        )?;
+        let source = PathList::from_string(&resolved_uploads_path.to_string_lossy())?;
+
         let mut snap = SnapshotOptions::default()
             .add_tags(
                 format!(

src/snapshot.rs

@@ -75,7 +75,7 @@ impl Snapshot {
                 .last()
                 .unwrap()
                 .strip_prefix(&prefix)
-                .unwrap()
+                .ok_or(anyhow::anyhow!("Could not find tag {}", key))?
                 .to_string());
         } else {
             Err(anyhow::anyhow!("Could not find tag {}", key))

tests/common/content_generator.rs

@@ -0,0 +1,40 @@
+use std::{fs, path::PathBuf};
+
+use rand::distributions::Alphanumeric;
+use rand::{prelude::*, thread_rng, Rng};
+
+pub fn generate_random_uploads(path: &PathBuf, size_limit: u64) -> anyhow::Result<()> {
+    let exts = vec!["jpg", "png", "pdf"];
+    let mut sz = 0u64;
+    let min_sz = 1024 * 100;
+    let max_sz = 1024 * 2048;
+
+    if !path.exists() {
+        fs::create_dir_all(path)?;
+    }
+
+    while sz < size_limit {
+        let filename = format!(
+            "{}-{}.{}",
+            thread_rng()
+                .sample_iter(&Alphanumeric)
+                .take(10)
+                .map(|x| x as char)
+                .collect::<String>(),
+            sz,
+            exts.choose(&mut rand::thread_rng()).unwrap()
+        );
+
+        let gen_size = rand::thread_rng().gen_range(min_sz..max_sz);
+        sz = sz + gen_size;
+
+        if sz <= size_limit {
+            fs::write(
+                path.join(filename),
+                format!("{:0width$}", "", width = gen_size as usize),
+            )?;
+        }
+    }
+
+    Ok(())
+}

tests/common/fixture_facts.rs

@@ -5,7 +5,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct FixtureFacts {
     pub path: PathBuf,
     pub is_wordpress_installed: bool,
@@ -25,7 +25,15 @@ impl ProjectFactProvider for FixtureFacts {
     }
 
     fn get_uploads_dir(&self) -> Result<String> {
-        Ok(self.path.join("uploads/").to_string_lossy().to_string())
+        let uploads_path = self.path.join("uploads/");
+        if !uploads_path.exists() {
+            fs::create_dir(&uploads_path)?;
+        }
+
+        Ok(fs::canonicalize(uploads_path)
+            .unwrap()
+            .to_string_lossy()
+            .to_string())
     }
 
     fn generate_unique_hash(&self) -> Result<Option<String>> {

tests/common/mod.rs

@@ -1,49 +1,98 @@
 use anyhow::Result;
-use assert_cmd::Command;
-use predicates::prelude::*;
-use pretty_assertions::assert_eq;
+use rand::distributions::Alphanumeric;
+use rand::{thread_rng, Rng};
+use rustic_backend::BackendOptions;
+use rustic_core::{ConfigOptions, KeyOptions, RepositoryOptions};
 use sprout::engine::Engine;
-use std::{fs, path::PathBuf};
+use sprout::facts::ProjectFactProvider;
+use sprout::repo::definition::RepositoryDefinition;
+use sprout::repo::ProjectRepository;
 use tempfile::TempDir;
 
+use self::fixture_facts::FixtureFacts;
+
+pub mod content_generator;
 pub mod fixture_facts;
 
 pub type TestResult = Result<()>;
 
 #[derive(Debug)]
 pub struct TestContext {
     pub sprout_home: TempDir,
-    pub project_path: TempDir,
     pub repo_path: TempDir,
     pub engine: Engine,
 }
 
 impl TestContext {
     pub fn new() -> Result<Self> {
         let sprout_home = TempDir::new()?;
-        let project_path = TempDir::new()?;
         let repo_path = TempDir::new()?;
 
         Ok(Self {
             engine: Engine {
                 sprout_home: sprout_home.path().to_path_buf(),
             },
             sprout_home,
-            project_path,
             repo_path,
         })
     }
+
+    pub fn setup_single_repo(&self) -> Result<()> {
+        self.engine.ensure_home()?;
+
+        RepositoryDefinition::create(
+            &RepositoryDefinition {
+                access_key: "TEST".to_string(),
+                repo: BackendOptions {
+                    repository: Some(self.repo_path.path().to_string_lossy().to_string()),
+                    ..BackendOptions::default()
+                },
+            },
+            &self.engine.get_home().join("repos/test.yaml"),
+        )?;
+
+        let mut sprout_config = self.engine.get_config()?;
+        sprout_config.default_repo = "test".to_string();
+        self.engine.write_config(&sprout_config)?;
+
+        let (_, definition) = RepositoryDefinition::get(&self.engine, "test")?;
+        let repo_opts = RepositoryOptions::default().password(definition.access_key);
+
+        let _ = ProjectRepository::initialise(
+            definition.repo.clone(),
+            repo_opts,
+            KeyOptions::default(),
+            ConfigOptions::default(),
+        )?;
+
+        Ok(())
+    }
 }
 
-pub fn run(args: &[&str], expected_file: &str) -> Result<()> {
-    let expected = fs::read_to_string(expected_file)?;
-    let output = Command::cargo_bin("sprout")?
-        .args(args)
-        .output()
-        .expect("fail");
+#[derive(Debug)]
+pub struct TestProjectContext {
+    pub project_path: TempDir,
+    pub facts: Box<dyn ProjectFactProvider>,
+}
 
-    let stdout = String::from_utf8(output.stdout).expect("invalid UTF-8");
-    assert_eq!(stdout, expected);
+impl TestProjectContext {
+    pub fn new(home_url: &str) -> Result<Self> {
+        let project_path = TempDir::new()?;
 
-    Ok(())
+        Ok(Self {
+            facts: Box::new(FixtureFacts {
+                path: project_path.path().to_path_buf(),
+                is_wordpress_installed: true,
+                home_url: home_url.to_string(),
+                hash: Some(
+                    thread_rng()
+                        .sample_iter(&Alphanumeric)
+                        .take(32)
+                        .map(|x| x as char)
+                        .collect(),
+                ),
+            }),
+            project_path,
+        })
+    }
 }