What is the correct way to write to temp file during unit tests with Maven?

I have written a unit test that writes a file to the file-system, given no path it writes to the working directory; so if executed from the project directory it writes in the project root, if in the projects parent directory it writes to the parents root directory.

So what is the correct way to write to the target directory? Quite possibly a directory inside the target directory?

If I quite simply specify target/ with the file it will write to the parent projects target instead of the projects target.

UPDATE: I actually want the file after the test finishes. The file is for an extraction format for third-parties that needs to be sent to the third parties. The test can be switched on/off to allow me to only run if the format of the file changes for re-approval. It's not a huge problem where the file goes, but I would like something that's easy to find.

You could try to use TemporaryFolder JUnit @Rule as described here

> The TemporaryFolder creates a folder in the default temporary file directory specified by the system property java.io.tmpdir. The method newFile creates a new file in the temporary directory and newFolder creates a new folder. > >When the test method finishes, JUnit automatically deletes all files and directories in and including the TemporaryFolder. JUnit guarantees to delete the resources, whether the test passes or fails.

---

After Question Updated

You can change the working directory used by maven-surefire-plugin.

<plugins>
    [...]
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>2.12.3</version>
        <configuration>
          <workingDirectory>${project.build.directory}</workingDirectory>
        </configuration>
      </plugin>
    [...]
</plugins>

You can change that working directory to anything you need for your tests like ${project.build.directory}/my_special_dir/.

The working directory in surefire plugin only affects tests being run and ONLY for tests being conducted by maven. If you run your tests from within an IDE the working directory will be something else.

No need to reinvent the wheel...

The JDK provides a way to a create temporary file, and a way to automatically delete it on exit:

File file = File.createTempFile( "some-prefix", "some-ext");
file.deleteOnExit();

Use the file and it will be deleted automatically when your test finishes. That's all there is to it.

To specify the directory to use for temporary files, use the overloaded method:

File file = File.createTempFile( "prefix", "ext", new File("/some/dir/path"));

I would write a routine which determines where the file should be written to, which i unitest afterwards, in general i try to avoid (as possible) accessing persistent data in unittests, like file IO or database access, this has performance reasons and others too.

Take a look at this asnwer: https://stackoverflow.com/a/8032504/395659

You will want to be able to run your tests both from an IDE as well as from Maven, so best practice is to write your tests so that they do not assume they are being run within Maven.

One of the best ways to deal with temporary files is using junit rules. This allows you to rely on the rule to clean up for you.

To state it beforehand, I am strongly against doing such things in unit test. I haven't really tried this but it should work:

Assume you are using surefire plugin, from the document it quoted that you can access the base directory of project under test by System.getProperty("basedir"). Get it and create files under basedir/target.

A more "appropriate" way (as we may have chance that we configured output directory to something else, you can change the surefire plugin config to something like this:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.6</version>
    <configuration>
        <systemPropertyVariables>
            <myOutDir>${project.build.outputDirectory}</myOutDir>
        </systemPropertyVariables>
    </configuration>
</plugin>

Then you can get the actual output directory by System.getProperty("myOutDir") in your test.

Temporary files should be created into temporary directory. Retrieve it using call System.getProperty("java.io.tmpdir")

Temporary file should be temporary, i.e. should be removed when it is not needed. To acheive this do not forget to delete it in finally block or in code that runs after the test, i.e.:

File tmpFile = ...
try {
   // deal with tempFile
} finally {
    tempFile.delete();
}

and/or

public class MyTestCase {
    private File tmpFile = null;

    @Before
    public void setUp() {
        tmpFile = ...;
    }

    @Test
    public void setUp() {
        // deal with tmpFile
    }

    @After
    public void setUp() {
        tmpFile.delete();
    }
}

Use File.createTempFile(String prefix, String suffix) if it is possible, i.e. you can then use file with special name generated by createTempFile().

Use file.deleteOnExit(). This creates hook that removes file automatically when JVM is terminated. The file will remain only if JVM was killed with kill -9, so it did not have a chance to run shutdown code.

Since JUnit 5 you can use @TempDir. It will be deleted (including its content) after the test(s).

either one temporary directory for every test:

@Test
void testWithTempFiles(@TempDir Path tempDir) 
    Path file = dir.resolve("temp_file.txt");
    ...
}

or a single one for all tests in the class:

@TempDir
static Path tempDir

@Test
void testWithTempFiles() 
    Path file = dir.resolve("temp_file.txt");
    ...
}