From e49bf6f7ed9613b5f505022729cb2aead08cfbca Mon Sep 17 00:00:00 2001 From: ShiXin Huang Date: Tue, 5 Mar 2024 01:17:54 +0800 Subject: [PATCH] test: improve test code (#60) * done * fix --- src/colorize.rs | 2 +- src/config.rs | 39 +++++--- src/json.rs | 59 ++++++++---- src/path_ext.rs | 45 +++++---- src/repository.rs | 1 + src/repository_config.rs | 42 ++++---- src/scafalra.rs | 202 ++++++++++++++++++++++++--------------- src/store.rs | 184 +++++++++++++++++++++-------------- 8 files changed, 347 insertions(+), 227 deletions(-) diff --git a/src/colorize.rs b/src/colorize.rs index 057a1c6..bf28156 100644 --- a/src/colorize.rs +++ b/src/colorize.rs @@ -31,7 +31,7 @@ mod tests { use super::Colorize; #[test] - fn test_no_color() { + fn test_no_color_when_test() { assert_eq!("foo".blue(), "foo"); assert_eq!("foo".to_string().blue(), "foo"); } diff --git a/src/config.rs b/src/config.rs index c1916e0..4a07032 100644 --- a/src/config.rs +++ b/src/config.rs @@ -53,30 +53,30 @@ mod test_utils { pub struct ConfigMock { pub config: Config, - pub tmpdir: TempDir, + pub tmp_dir: TempDir, } impl ConfigMock { pub fn new() -> Self { - let tmpdir = tempdir().unwrap(); - let config = Config::new(tmpdir.path()).unwrap(); + let tmp_dir = tempdir().unwrap(); + let config = Config::new(tmp_dir.path()).unwrap(); Self { - tmpdir, + tmp_dir, config, } } pub fn with_content(self) -> Self { - let tmpdir_path = self.tmpdir.path(); + let tmp_dir_path = self.tmp_dir.path(); fs::write( - tmpdir_path.join(Config::FILE_NAME), + tmp_dir_path.join(Config::FILE_NAME), "{\n \"token\": \"token\"\n}", ) .unwrap(); - let config = Config::new(tmpdir_path).unwrap(); + let config = Config::new(tmp_dir_path).unwrap(); Self { config, @@ -96,26 +96,35 @@ mod tests { #[test] fn test_config_new_not_exists() { - let config_mock = ConfigMock::new(); + let ConfigMock { + tmp_dir: _tmp_dir, + config, + } = ConfigMock::new(); - assert_eq!(config_mock.config.token(), None); + assert_eq!(config.token(), None); } #[test] fn test_config_new_exists() { - let config_mock = ConfigMock::new().with_content(); + let ConfigMock { + tmp_dir: _tmp_dir, + config, + } = ConfigMock::new().with_content(); - assert_eq!(config_mock.config.token(), Some("token")); + assert_eq!(config.token(), Some("token")); } #[test] fn test_config_save() -> Result<()> { - let mut config_mock = ConfigMock::new(); + let ConfigMock { + tmp_dir: _tmp_dir, + mut config, + } = ConfigMock::new(); - config_mock.config.set_token("token2"); - config_mock.config.save()?; + config.set_token("token2"); + config.save()?; - let actual = fs::read_to_string(&config_mock.config.path)?; + let actual = fs::read_to_string(&config.path)?; assert_eq!(actual, "{\n \"token\": \"token2\"\n}"); Ok(()) diff --git a/src/json.rs b/src/json.rs index 41bb11e..1fc8c2f 100644 --- a/src/json.rs +++ b/src/json.rs @@ -16,6 +16,7 @@ where return Ok(value); } } + let default = Self::default(); fs::write(file_path, serde_json::to_string_pretty(&default)?)?; @@ -48,24 +49,24 @@ mod test_utils { pub struct JsonContentMock { pub foo: Foo, - pub tmpdir: TempDir, + pub tmp_dir: TempDir, pub path: PathBuf, } impl JsonContentMock { pub fn new() -> Self { - let tmpdir = tempdir().unwrap(); - let file_path = tmpdir.path().join("foo.json"); - let foo = Foo::load(&file_path).unwrap(); + let tmp_dir = tempdir().unwrap(); + let path = tmp_dir.path().join("foo.json"); + let foo = Foo::load(&path).unwrap(); Self { foo, - tmpdir, - path: file_path, + tmp_dir, + path, } } - pub fn with_empty_content(self) -> Self { + pub fn no_content(self) -> Self { fs::write(&self.path, "").unwrap(); let foo = Foo::load(&self.path).unwrap(); @@ -99,34 +100,50 @@ mod tests { #[test] fn test_json_load_file() { - let json_content_mock = JsonContentMock::new().with_content(); + let JsonContentMock { + tmp_dir: _tmp_dir, + foo, + .. + } = JsonContentMock::new().with_content(); - assert_eq!(json_content_mock.foo.bar, "bar"); + assert_eq!(foo.bar, "bar"); } #[test] - fn test_json_load_empty_content() { - let json_content_mock = JsonContentMock::new().with_empty_content(); - - assert_eq!(json_content_mock.foo.bar, ""); + fn test_json_load_no_content() { + let JsonContentMock { + tmp_dir: _tmp_dir, + foo, + .. + } = JsonContentMock::new().no_content(); + + assert_eq!(foo.bar, ""); } #[test] fn test_json_load_file_not_exists() { - let json_content_mock = JsonContentMock::new(); - - assert_eq!(json_content_mock.foo.bar, ""); - assert!(json_content_mock.path.exists()); + let JsonContentMock { + tmp_dir: _tmp_dir, + foo, + path, + } = JsonContentMock::new(); + + assert_eq!(foo.bar, ""); + assert!(path.exists()); } #[test] fn test_json_save() -> Result<()> { - let mut json_content_mock = JsonContentMock::new().with_content(); + let JsonContentMock { + tmp_dir: _tmp_dir, + mut foo, + path, + } = JsonContentMock::new().with_content(); - json_content_mock.foo.bar = "bar2".to_string(); - json_content_mock.foo.save(&json_content_mock.path)?; + foo.bar = "bar2".to_string(); + foo.save(&path)?; - let actual = fs::read_to_string(&json_content_mock.path)?; + let actual = fs::read_to_string(&path)?; assert_eq!(actual, "{\n \"bar\": \"bar2\"\n}"); Ok(()) diff --git a/src/path_ext.rs b/src/path_ext.rs index 2ad14a9..50696ac 100644 --- a/src/path_ext.rs +++ b/src/path_ext.rs @@ -1,25 +1,5 @@ use std::path::{Path, PathBuf}; -#[cfg(test)] -use path_slash::PathBufExt; - -#[cfg(test)] -pub trait JoinSlash { - fn join_slash(&self, s: T) -> PathBuf - where - T: AsRef; -} - -#[cfg(test)] -impl JoinSlash for Path { - fn join_slash(&self, s: T) -> PathBuf - where - T: AsRef, - { - self.join(PathBuf::from_slash(s)) - } -} - pub trait JoinIter { fn join_iter(&self, iter: T) -> PathBuf where @@ -34,3 +14,28 @@ impl> JoinIter for Path { self.join(PathBuf::from_iter(iter)) } } + +#[cfg(test)] +pub use join_slash_ext::JoinSlash; + +#[cfg(test)] +mod join_slash_ext { + use std::path::{Path, PathBuf}; + + use path_slash::PathBufExt; + + pub trait JoinSlash { + fn join_slash(&self, s: T) -> PathBuf + where + T: AsRef; + } + + impl JoinSlash for Path { + fn join_slash(&self, s: T) -> PathBuf + where + T: AsRef, + { + self.join(PathBuf::from_slash(s)) + } + } +} diff --git a/src/repository.rs b/src/repository.rs index 4577613..2c476a3 100644 --- a/src/repository.rs +++ b/src/repository.rs @@ -71,6 +71,7 @@ mod tests { #[test_case("foo/bar/baz"; "paths exceeded")] fn test_repo_parse_err(input: &str) { let repo = Repository::parse(input); + assert!(repo.is_err()); } } diff --git a/src/repository_config.rs b/src/repository_config.rs index 71199de..cb06985 100644 --- a/src/repository_config.rs +++ b/src/repository_config.rs @@ -39,30 +39,30 @@ mod test_utils { pub struct RepositoryConfigMock { pub repo_cfg: RepositoryConfig, - pub tmpdir: TempDir, + pub tmp_dir: TempDir, pub path: PathBuf, } impl RepositoryConfigMock { pub fn new() -> Self { - let tmpdir = tempdir().unwrap(); - let tmpdir_path = tmpdir.path().to_path_buf(); - let repo_cfg = RepositoryConfig::load(&tmpdir_path); + let tmp_dir = tempdir().unwrap(); + let path = tmp_dir.path().to_path_buf(); + let repo_cfg = RepositoryConfig::load(&path); Self { repo_cfg, - tmpdir, - path: tmpdir_path, + tmp_dir, + path, } } pub fn with_fixture(self) -> Self { - let fixture_path = PathBuf::from("fixtures"); - let repo_cfg = RepositoryConfig::load(&fixture_path); + let path = PathBuf::from("fixtures"); + let repo_cfg = RepositoryConfig::load(&path); Self { repo_cfg, - path: fixture_path, + path, ..self } } @@ -73,26 +73,30 @@ mod test_utils { mod tests { use std::collections::HashMap; - use anyhow::Result; - use super::test_utils::RepositoryConfigMock; #[test] fn test_config_file_load() { - let repo_cfg_mock = RepositoryConfigMock::new().with_fixture(); + let RepositoryConfigMock { + tmp_dir: _tmp_dir, + repo_cfg, + .. + } = RepositoryConfigMock::new().with_fixture(); assert_eq!( - repo_cfg_mock.repo_cfg.copy_on_add, + repo_cfg.copy_on_add, HashMap::from_iter([("foo".to_string(), vec!["baz".to_string()])]) ); } #[test] - fn test_config_load_file_not_exists() -> Result<()> { - let repo_cfg_mock = RepositoryConfigMock::new(); - - assert!(repo_cfg_mock.repo_cfg.copy_on_add.is_empty()); - - Ok(()) + fn test_config_load_file_not_exists() { + let RepositoryConfigMock { + tmp_dir: _tmp_dir, + repo_cfg, + .. + } = RepositoryConfigMock::new(); + + assert!(repo_cfg.copy_on_add.is_empty()); } } diff --git a/src/scafalra.rs b/src/scafalra.rs index 4b90ce4..a28e5c1 100644 --- a/src/scafalra.rs +++ b/src/scafalra.rs @@ -173,7 +173,7 @@ impl Scafalra { self.store.add( TemplateBuilder::new( &file_name, - &repo.url(), + repo.url(), &sub_template_dir, ) .sub_template(true) @@ -271,6 +271,7 @@ impl Scafalra { .filter(|v| !v.is_empty()) .collect::>(); + globs.sort_unstable(); globs.dedup(); if let Ok(gw) = globwalk::GlobWalkerBuilder::from_patterns(from, &globs) @@ -284,9 +285,9 @@ impl Scafalra { pub fn rename(&mut self, args: RenameArgs) -> Result<()> { debug!("args: {:#?}", args); - let is_renamed = self.store.rename(&args.name, &args.new_name); + let renamed = self.store.rename(&args.name, &args.new_name); - if is_renamed { + if renamed { self.store.save()?; } @@ -336,15 +337,15 @@ mod test_utils { pub struct ScafalraMock { pub scafalra: Scafalra, - pub tmpdir: TempDir, + pub tmp_dir: TempDir, endpoint_cache: Option, } impl ScafalraMock { pub fn new() -> Self { - let tmpdir = tempdir().unwrap(); + let tmp_dir = tempdir().unwrap(); let scafalra = Scafalra::new( - tmpdir.path().join("scafalra"), + tmp_dir.path().join("scafalra"), None, Some("token"), ) @@ -352,7 +353,7 @@ mod test_utils { Self { scafalra, - tmpdir, + tmp_dir, endpoint_cache: None, } } @@ -443,25 +444,36 @@ mod tests { #[test] fn test_scafalra_new() { - let scafalra_mock = ScafalraMock::new(); - - assert!(scafalra_mock.scafalra.cache_dir.exists()); - assert!(scafalra_mock.scafalra.store.path.exists()); - assert!(scafalra_mock.scafalra.config.path.exists()); + let ScafalraMock { + tmp_dir: _tmp_dir, + scafalra, + .. + } = ScafalraMock::new(); + + assert!(scafalra.cache_dir.exists()); + assert!(scafalra.store.path.exists()); + assert!(scafalra.config.path.exists()); } #[test] fn test_scafalra_add() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, + download_mock, + } = ServerMock::new(); + + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - scafalra_mock.scafalra.add(AddArgsMock::new().build())?; + scafalra.add(AddArgsMock::new().build())?; - repo_server_mock.download_mock.assert(); + download_mock.assert(); - let bar_dir = scafalra_mock.scafalra.cache_dir.join_slash("foo/bar"); - let actual = fs::read_to_string(&scafalra_mock.scafalra.store.path)?; + let bar_dir = scafalra.cache_dir.join_slash("foo/bar"); + let actual = fs::read_to_string(&scafalra.store.path)?; let expect = StoreJsonMock::new().push("bar", &bar_dir).build(); assert!(bar_dir.exists()); @@ -472,18 +484,23 @@ mod tests { #[test] fn test_scafalra_add_specified_name() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, + download_mock, + } = ServerMock::new(); - scafalra_mock - .scafalra - .add(AddArgsMock::new().name("foo").build())?; + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - repo_server_mock.download_mock.assert(); + scafalra.add(AddArgsMock::new().name("foo").build())?; - let bar_dir = scafalra_mock.scafalra.cache_dir.join_slash("foo/bar"); - let actual = fs::read_to_string(&scafalra_mock.scafalra.store.path)?; + download_mock.assert(); + + let bar_dir = scafalra.cache_dir.join_slash("foo/bar"); + let actual = fs::read_to_string(&scafalra.store.path)?; let expect = StoreJsonMock::new().push("foo", &bar_dir).build(); assert!(bar_dir.exists()); @@ -494,18 +511,23 @@ mod tests { #[test] fn test_scafalra_add_depth_1() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, + download_mock, + } = ServerMock::new(); + + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - scafalra_mock - .scafalra - .add(AddArgsMock::new().depth(1).build())?; + scafalra.add(AddArgsMock::new().depth(1).build())?; - repo_server_mock.download_mock.assert(); + download_mock.assert(); - let bar_dir = scafalra_mock.scafalra.cache_dir.join_slash("foo/bar"); - let actual = fs::read_to_string(&scafalra_mock.scafalra.store.path)?; + let bar_dir = scafalra.cache_dir.join_slash("foo/bar"); + let actual = fs::read_to_string(&scafalra.store.path)?; let expect = StoreJsonMock::new() .push("a", bar_dir.join("a")) .push("b", bar_dir.join("b")) @@ -522,19 +544,23 @@ mod tests { #[test] fn test_scafalra_add_subdir() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, + download_mock, + } = ServerMock::new(); - scafalra_mock - .scafalra - .add(AddArgsMock::new().subdir("/a/a1").build())?; + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - repo_server_mock.download_mock.assert(); + scafalra.add(AddArgsMock::new().subdir("/a/a1").build())?; - let a1_dir = - scafalra_mock.scafalra.cache_dir.join_slash("foo/bar/a/a1"); - let actual = fs::read_to_string(&scafalra_mock.scafalra.store.path)?; + download_mock.assert(); + + let a1_dir = scafalra.cache_dir.join_slash("foo/bar/a/a1"); + let actual = fs::read_to_string(&scafalra.store.path)?; let expect = StoreJsonMock::new().push("a1", &a1_dir).build(); assert!(a1_dir.exists()); @@ -545,21 +571,26 @@ mod tests { #[test] fn test_scafalra_add_subdir_and_depth_1() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, + download_mock, + } = ServerMock::new(); + + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - scafalra_mock - .scafalra - .add(AddArgsMock::new().subdir("/a").depth(1).build())?; + scafalra.add(AddArgsMock::new().subdir("/a").depth(1).build())?; - repo_server_mock.download_mock.assert(); + download_mock.assert(); - let a_dir = scafalra_mock.scafalra.cache_dir.join_slash("foo/bar/a"); + let a_dir = scafalra.cache_dir.join_slash("foo/bar/a"); let a1_dir = a_dir.join("a1"); let a2_dir = a_dir.join("a2"); let a3_dir = a_dir.join("a3"); - let actual = fs::read_to_string(&scafalra_mock.scafalra.store.path)?; + let actual = fs::read_to_string(&scafalra.store.path)?; let expect = StoreJsonMock::new() .push("a1", &a1_dir) .push("a2", &a2_dir) @@ -577,28 +608,36 @@ mod tests { #[test] fn test_scafalra_create() -> Result<()> { - let scafalra_mock = ScafalraMock::new().with_content(); + let ScafalraMock { + tmp_dir, + scafalra, + .. + } = ScafalraMock::new().with_content(); - let tmpdir_path = scafalra_mock.tmpdir.path(); + let tmp_dir_path = tmp_dir.path(); - scafalra_mock.scafalra.create(CreateArgs { + scafalra.create(CreateArgs { name: "bar".to_string(), // Due to chroot restrictions, a directory is specified here to // simulate the current working directory - directory: Some(tmpdir_path.join("bar")), + directory: Some(tmp_dir_path.join("bar")), with: None, })?; - assert!(tmpdir_path.join_slash("bar/baz.txt").exists()); + assert!(tmp_dir_path.join_slash("bar/baz.txt").exists()); Ok(()) } #[test] fn test_scafalra_create_not_found() -> Result<()> { - let scafalra_mock = ScafalraMock::new(); + let ScafalraMock { + tmp_dir: _tmp_dir, + scafalra, + .. + } = ScafalraMock::new(); - let ret = scafalra_mock.scafalra.create(CreateArgs { + let ret = scafalra.create(CreateArgs { name: "bar".to_string(), directory: None, with: None, @@ -615,16 +654,19 @@ mod tests { #[test] fn test_scafalra_copy_on_add() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, .. + } = ServerMock::new(); - scafalra_mock - .scafalra - .add(AddArgsMock::new().depth(1).build())?; + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - let template_dir = - scafalra_mock.scafalra.cache_dir.join_slash("foo/bar"); + scafalra.add(AddArgsMock::new().depth(1).build())?; + + let template_dir = scafalra.cache_dir.join_slash("foo/bar"); let a_dir = template_dir.join("a"); assert!(is_all_exists(&[ @@ -647,18 +689,22 @@ mod tests { #[test] fn test_scafalra_copy_on_create() -> Result<()> { - let repo_server_mock = ServerMock::new(); - let mut scafalra_mock = - ScafalraMock::new().endpoint(&repo_server_mock.server.url()); + let ServerMock { + server, .. + } = ServerMock::new(); + + let ScafalraMock { + tmp_dir: _tmp_dir, + mut scafalra, + .. + } = ScafalraMock::new().endpoint(&server.url()); - scafalra_mock - .scafalra - .add(AddArgsMock::new().depth(1).build())?; + scafalra.add(AddArgsMock::new().depth(1).build())?; let tmp_dir = tempdir()?; let dest = tmp_dir.path().join("dest"); - scafalra_mock.scafalra.create(CreateArgs { + scafalra.create(CreateArgs { name: "b".to_string(), directory: Some(dest.clone()), with: Some("common.txt,copy-dir,copy-all-in-dir/**".to_string()), diff --git a/src/store.rs b/src/store.rs index 7b6c5a6..e0b9de3 100644 --- a/src/store.rs +++ b/src/store.rs @@ -2,7 +2,6 @@ use std::{ collections::BTreeMap, ops::{Deref, DerefMut}, path::{Path, PathBuf}, - slice::Iter, }; use anyhow::Result; @@ -135,8 +134,10 @@ impl Changes { self } - fn iter(&self) -> Iter<'_, String> { - self.inner.iter() + fn print_all(&self) { + for ele in &self.inner { + println!("{}", ele); + } } } @@ -163,10 +164,7 @@ impl Store { pub fn save(&self) -> Result<()> { self.templates.save(&self.path)?; - - self.changes.iter().for_each(|v| { - println!("{}", v); - }); + self.changes.print_all(); Ok(()) } @@ -185,7 +183,6 @@ impl Store { pub fn remove(&mut self, name: &str) -> Result<()> { if let Some(template) = self.templates.get(name) { remove_dir_all(&template.path)?; - self.changes.push_remove(name); self.templates.remove(name); } @@ -366,28 +363,28 @@ pub mod test_utils { pub struct StoreMock { pub store: Store, - pub tmpdir: TempDir, + pub tmp_dir: TempDir, pub path: PathBuf, } impl StoreMock { pub fn new() -> Self { - let tmpdir = tempdir().unwrap(); - let tmp_dir_path = tmpdir.path(); - let foo_path = tmp_dir_path.join("foo"); + let tmp_dir = tempdir().unwrap(); + let tmp_dir_path = tmp_dir.path(); + let path = tmp_dir_path.join("foo"); let store = Store::new(tmp_dir_path).unwrap(); Self { store, - tmpdir, - path: foo_path, + tmp_dir, + path, } } pub fn with_content(self) -> Self { fs::create_dir(&self.path).unwrap(); let content = StoreJsonMock::new().push("foo", &self.path).build(); - let tmp_dir_path = self.tmpdir.path(); + let tmp_dir_path = self.tmp_dir.path(); let store_file = tmp_dir_path.join(Store::FILE_NAME); fs::write(store_file, content).unwrap(); let store = Store::new(tmp_dir_path).unwrap(); @@ -411,28 +408,40 @@ mod tests { #[test] fn test_store_new_file_not_exists() { - let store_mock = StoreMock::new(); + let StoreMock { + tmp_dir: _tmp_dir, + store, + .. + } = StoreMock::new(); - assert_eq!(store_mock.store.templates.len(), 0); - assert_eq!(store_mock.store.changes.inner.len(), 0); + assert_eq!(store.templates.len(), 0); + assert_eq!(store.changes.inner.len(), 0); } #[test] fn test_store_new() { - let store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + store, + .. + } = StoreMock::new().with_content(); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(store_mock.store.templates.contains_key("foo")); + assert_eq!(store.templates.len(), 1); + assert!(store.templates.contains_key("foo")); } #[test] fn test_store_save() -> Result<()> { - let store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + store, + path, + } = StoreMock::new().with_content(); - store_mock.store.save()?; + store.save()?; - let actual = fs::read_to_string(store_mock.store.path)?; - let expect = StoreJsonMock::new().push("foo", &store_mock.path).build(); + let actual = fs::read_to_string(store.path)?; + let expect = StoreJsonMock::new().push("foo", &path).build(); assert_eq!(actual, expect); @@ -441,111 +450,139 @@ mod tests { #[test] fn test_store_add() { - let mut store_mock = StoreMock::new(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new(); - store_mock.store.add(TemplateMock::build("foo")); + store.add(TemplateMock::build("foo")); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(store_mock.store.templates.contains_key("foo")); - assert_eq!(store_mock.store.changes.inner, vec!["+ foo"]); + assert_eq!(store.templates.len(), 1); + assert!(store.templates.contains_key("foo")); + assert_eq!(store.changes.inner, vec!["+ foo"]); } #[test] fn test_store_add_same() { - let mut store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new().with_content(); - store_mock.store.add(TemplateMock::build("foo")); + store.add(TemplateMock::build("foo")); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(store_mock.store.templates.contains_key("foo")); - assert_eq!(store_mock.store.changes.inner, vec!["- foo", "+ foo"]); + assert_eq!(store.templates.len(), 1); + assert!(store.templates.contains_key("foo")); + assert_eq!(store.changes.inner, vec!["- foo", "+ foo"]); } #[test] fn test_store_remove() -> Result<()> { - let mut store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + path, + } = StoreMock::new().with_content(); - store_mock.store.remove("foo")?; + store.remove("foo")?; - assert!(!store_mock.path.exists()); - assert_eq!(store_mock.store.templates.len(), 0); - assert_eq!(store_mock.store.changes.inner, vec!["- foo"]); + assert!(!path.exists()); + assert_eq!(store.templates.len(), 0); + assert_eq!(store.changes.inner, vec!["- foo"]); Ok(()) } #[test] fn test_store_remove_not_found() -> Result<()> { - let mut store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new().with_content(); - store_mock.store.remove("bar")?; + store.remove("bar")?; - assert_eq!(store_mock.store.changes.inner.len(), 0); + assert_eq!(store.changes.inner.len(), 0); Ok(()) } #[test] fn test_store_rename() { - let mut store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new().with_content(); - store_mock.store.rename("foo", "bar"); + store.rename("foo", "bar"); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(!store_mock.store.templates.contains_key("foo")); - assert!(store_mock.store.templates.contains_key("bar")); - assert_eq!(store_mock.store.changes.inner, vec!["- foo", "+ bar"]); + assert_eq!(store.templates.len(), 1); + assert!(!store.templates.contains_key("foo")); + assert!(store.templates.contains_key("bar")); + assert_eq!(store.changes.inner, vec!["- foo", "+ bar"]); } #[test] fn store_rename_exists_or_not_found() { - let mut store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new().with_content(); - store_mock.store.rename("foo", "foo"); + store.rename("foo", "foo"); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(store_mock.store.templates.contains_key("foo")); + assert_eq!(store.templates.len(), 1); + assert!(store.templates.contains_key("foo")); - store_mock.store.rename("bar", "foo"); + store.rename("bar", "foo"); - assert_eq!(store_mock.store.templates.len(), 1); - assert!(store_mock.store.templates.contains_key("foo")); + assert_eq!(store.templates.len(), 1); + assert!(store.templates.contains_key("foo")); } #[test] fn test_print_grid() { - let mut store_mock = StoreMock::new(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new(); - assert_eq!(store_mock.store.print_grid(), None); + assert_eq!(store.print_grid(), None); for i in 0..7 { - store_mock - .store - .add(TemplateMock::build(&format!("foo-{}", i))); + store.add(TemplateMock::build(&format!("foo-{}", i))); } assert_eq!( - store_mock.store.print_grid().unwrap(), + store.print_grid().unwrap(), "foo-0 foo-1 foo-2 foo-3 foo-4 foo-5\nfoo-6" ); } #[test] fn test_print_table() -> Result<()> { - let mut store_mock = StoreMock::new(); + let StoreMock { + tmp_dir: _tmp_dir, + mut store, + .. + } = StoreMock::new(); - assert_eq!(store_mock.store.print_table(), None); + assert_eq!(store.print_table(), None); for i in 0..2 { - store_mock - .store - .add(TemplateMock::build(&format!("foo-{}", i))); + store.add(TemplateMock::build(&format!("foo-{}", i))); } let expect = fs::read_to_string("fixtures/print-table.txt")?; assert_eq!( - Vec::from_iter(store_mock.store.print_table().unwrap().lines()), + Vec::from_iter(store.print_table().unwrap().lines()), Vec::from_iter(expect.lines()) ); @@ -554,11 +591,12 @@ mod tests { #[test] fn test_store_similar_name() { - let store_mock = StoreMock::new().with_content(); + let StoreMock { + tmp_dir: _tmp_dir, + store, + .. + } = StoreMock::new().with_content(); - assert_eq!( - store_mock.store.similar_name_suggestion("fop").similar, - Some("foo") - ); + assert_eq!(store.similar_name_suggestion("fop").similar, Some("foo")); } }