fix: don't ignore temporary directories before creation

Previously test creation would've tried to ignore the temporary directoties
before the were created. Now the ignoring is simply done on creation of the
directories. Additionally, ignoring now creates the directory to ignore.

Author: tingerrr

crates/typst-test-cli/src/cli/add.rs

@@ -50,20 +50,18 @@ pub fn run(ctx: &mut Context, args: &Args) -> eyre::Result<()> {
     }
 
     let paths = project.paths();
-    let vcs = project.vcs();
     let id = args.test.clone();
 
     if let Some(template) = suite.template().filter(|_| !args.no_template) {
         if args.ephemeral {
             Test::create(
                 paths,
-                vcs,
                 id,
                 template,
                 Some(Reference::Ephemeral(template.into())),
             )?;
         } else if args.compile_only {
-            Test::create(paths, vcs, id, template, None)?;
+            Test::create(paths, id, template, None)?;
         } else {
             let world = ctx.world(&args.compile)?;
 
@@ -78,10 +76,10 @@ pub fn run(ctx: &mut Context, args: &Args) -> eyre::Result<()> {
             );
             let doc = output?;
 
-            Test::create(paths, vcs, id, template, Some(Reference::Persistent(doc)))?;
+            Test::create(paths, id, template, Some(Reference::Persistent(doc)))?;
         };
     } else {
-        Test::create_default(paths, vcs, id)?;
+        Test::create_default(paths, id)?;
     }
 
     let mut w = ctx.ui.stderr();

crates/typst-test-cli/src/cli/init.rs

@@ -37,7 +37,6 @@ pub fn run(ctx: &mut Context, args: &Args) -> eyre::Result<()> {
     if !args.no_example {
         Test::create_default(
             project.paths(),
-            project.vcs(),
             Id::new("example").expect("the id is valid and unique"),
         )?;
     }

crates/typst-test-cli/src/cli/util/clean.rs

@@ -14,7 +14,7 @@ pub fn run(ctx: &mut Context) -> eyre::Result<()> {
     let len = suite.matched().len();
 
     for test in suite.matched().values() {
-        test.create_temporary_directories(project.paths())?;
+        test.create_temporary_directories(project.paths(), project.vcs())?;
     }
 
     let mut w = ctx.ui.stderr();

crates/typst-test-cli/src/runner.rs

@@ -144,6 +144,7 @@ impl TestRunner<'_, '_, '_> {
         // TODO(tinger): don't exit early if there are still exports possible
 
         let paths = self.project_runner.project.paths();
+        let vcs = self.project_runner.project.vcs();
 
         match self.project_runner.config.action {
             Action::Run {
@@ -213,7 +214,7 @@ impl TestRunner<'_, '_, '_> {
                     let output = self.compile_out_doc(output)?;
                     let output = self.render_out_doc(output)?;
 
-                    self.test.create_reference_documents(paths, &output)?;
+                    self.test.create_reference_documents(paths, vcs, &output)?;
 
                     if export {
                         let reference = self.load_ref_doc()?;
@@ -249,8 +250,10 @@ impl TestRunner<'_, '_, '_> {
     pub fn prepare(&mut self) -> eyre::Result<()> {
         tracing::trace!(test = ?self.test.id(), "clearing temporary directories");
 
-        self.test
-            .create_temporary_directories(self.project_runner.project.paths())?;
+        self.test.create_temporary_directories(
+            self.project_runner.project.paths(),
+            self.project_runner.project.vcs(),
+        )?;
 
         Ok(())
     }

crates/typst-test-lib/src/project/vcs.rs

@@ -7,6 +7,7 @@ use std::fmt::{self, Debug, Display};
 use std::path::{Path, PathBuf};
 use std::{fs, io};
 
+use crate::stdx;
 use crate::stdx::result::ResultEx;
 
 /// The name of the git ignore file.
@@ -85,10 +86,12 @@ impl Vcs {
         match self.kind {
             Kind::Git => {
                 let gitignore = path.join(GITIGNORE_NAME);
+                stdx::fs::create_dir(path, true)?;
                 fs::write(gitignore, GITIGNORE_CONTENT)?;
             }
             Kind::Mercurial => {
                 let hgignore = path.join(HGIGNORE_NAME);
+                stdx::fs::create_dir(path, true)?;
                 fs::write(hgignore, HGIGNORE_CONTENT)?;
             }
         }

crates/typst-test-lib/src/test/mod.rs

@@ -179,10 +179,9 @@ impl Test {
 
 impl Test {
     /// Creates a new default test on disk.
-    pub fn create_default(paths: &Paths, vcs: Option<&Vcs>, id: Id) -> Result<Test, CreateError> {
+    pub fn create_default(paths: &Paths, id: Id) -> Result<Test, CreateError> {
         Self::create(
             paths,
-            vcs,
             id,
             DEFAULT_TEST_INPUT,
             Some(Reference::Persistent(Document::new([Pixmap::decode_png(
@@ -195,7 +194,6 @@ impl Test {
     /// Creates a new test on disk.
     pub fn create(
         paths: &Paths,
-        vcs: Option<&Vcs>,
         id: Id,
         source: &str,
         reference: Option<Reference>,
@@ -236,20 +234,16 @@ impl Test {
                 this.create_reference_script(paths, reference.as_str())?;
             }
             Some(Reference::Persistent(reference)) => {
-                this.create_reference_documents(paths, &reference)?;
+                this.create_reference_documents(paths, None, &reference)?;
             }
             None => {}
         }
 
-        if let Some(vcs) = vcs {
-            this.ignore_temporary_directories(paths, vcs)?;
-        }
-
         Ok(this)
     }
 
     /// Creates this test's temporary directories, if they don't exist yet.
-    pub fn create_temporary_directories(&self, paths: &Paths) -> io::Result<()> {
+    pub fn create_temporary_directories(&self, paths: &Paths, vcs: Option<&Vcs>) -> io::Result<()> {
         self.delete_temporary_directories(paths)?;
 
         if self.kind.is_ephemeral() {
@@ -258,6 +252,11 @@ impl Test {
 
         stdx::fs::create_dir(paths.test_out_dir(&self.id), true)?;
         stdx::fs::create_dir(paths.test_diff_dir(&self.id), true)?;
+
+        if let Some(vcs) = vcs {
+            self.ignore_temporary_directories(paths, vcs)?;
+        }
+
         Ok(())
     }
 
@@ -279,6 +278,7 @@ impl Test {
     pub fn create_reference_documents(
         &self,
         paths: &Paths,
+        vcs: Option<&Vcs>,
         reference: &Document,
     ) -> Result<(), SaveError> {
         // NOTE(tinger): if there are already more pages than we want to create,
@@ -289,6 +289,13 @@ impl Test {
         let ref_dir = paths.test_ref_dir(&self.id);
         stdx::fs::create_dir(&ref_dir, true)?;
         reference.save(&ref_dir)?;
+
+        if self.kind().is_ephemeral() {
+            if let Some(vcs) = vcs {
+                self.ignore_reference_documents(paths, vcs)?;
+            }
+        }
+
         Ok(())
     }
 
@@ -381,7 +388,7 @@ impl Test {
         reference: &Document,
     ) -> Result<(), SaveError> {
         self.delete_reference_script(paths)?;
-        self.create_reference_documents(paths, reference)?;
+        self.create_reference_documents(paths, vcs, reference)?;
         if let Some(vcs) = vcs {
             self.unignore_reference_documents(paths, vcs)?;
         }
@@ -422,23 +429,22 @@ impl Test {
     /// Loads the reference test script source of this test, if this test is
     /// ephemeral.
     pub fn load_reference_source(&self, paths: &Paths) -> io::Result<Option<Source>> {
-        match self.kind {
-            Kind::Ephemeral => {
-                let ref_script = paths.test_ref_script(&self.id);
-                Ok(Some(Source::new(
-                    FileId::new(
-                        None,
-                        VirtualPath::new(
-                            ref_script
-                                .strip_prefix(paths.project_root())
-                                .unwrap_or(&ref_script),
-                        ),
-                    ),
-                    std::fs::read_to_string(ref_script)?,
-                )))
-            }
-            _ => Ok(None),
+        if !self.kind().is_ephemeral() {
+            return Ok(None);
         }
+
+        let ref_script = paths.test_ref_script(&self.id);
+        Ok(Some(Source::new(
+            FileId::new(
+                None,
+                VirtualPath::new(
+                    ref_script
+                        .strip_prefix(paths.project_root())
+                        .unwrap_or(&ref_script),
+                ),
+            ),
+            std::fs::read_to_string(ref_script)?,
+        )))
     }
 
     /// Loads the persistent reference pages of this test, if they exist.
@@ -501,16 +507,15 @@ mod tests {
     }
 
     #[test]
-    fn test_create_new() {
+    fn test_create() {
         _dev::fs::TempEnv::run(
             |root| root.setup_dir("tests"),
             |root| {
                 let paths = Paths::new(root, None);
-                Test::create(&paths, None, id("compile-only"), "Hello World", None).unwrap();
+                Test::create(&paths, id("compile-only"), "Hello World", None).unwrap();
 
                 Test::create(
                     &paths,
-                    None,
                     id("ephemeral"),
                     "Hello World",
                     Some(Reference::Ephemeral("Hello\nWorld".into())),
@@ -519,18 +524,21 @@ mod tests {
 
                 Test::create(
                     &paths,
-                    None,
                     id("persistent"),
                     "Hello World",
                     Some(Reference::Persistent(Document::new(vec![]))),
                 )
                 .unwrap();
+
+                Test::create_default(&paths, id("default")).unwrap();
             },
             |root| {
                 root.expect_file_content("tests/compile-only/test.typ", "Hello World")
                     .expect_file_content("tests/ephemeral/test.typ", "Hello World")
                     .expect_file_content("tests/ephemeral/ref.typ", "Hello\nWorld")
                     .expect_file_content("tests/persistent/test.typ", "Hello World")
+                    .expect_file_content("tests/default/test.typ", DEFAULT_TEST_INPUT)
+                    .expect_file("tests/default/ref/1.png")
                     .expect_dir("tests/persistent/ref")
             },
         );