flaque / filet

🍖 A small temporary file utility for Go testing.

Filet 🍖

A small temporary file utility for Go testing. Built on Afero and heavily inspired by the way Afero tests itself.

Install via: $ go get github.com/Flaque/filet

Then import with:

import (
  filet "github.com/Flaque/filet"
)

Quick overview at GoDocs.

Creating temporaries

Creating temporary directories:

func TestFoo(t *testing.T) {
  filet.TmpDir(t, "") // Creates a temporary dir with no parent directory
  filet.TmpDir(t, "myPath") // Creates a temporary dir at `myPath`
}

Creating temporary files:

func TestFoo(t *testing.T) {
  filet.TmpFile(t, "", "") // Creates a temporary file with no parent dir

  // Creates a temporary file with string "some content"
  filet.TmpFile(t, "", "some content")

  // Creates a temporary file with string "some content"
  filet.TmpFile(t, "myDir", "some content")
}

Creating specified files:

func TestFoo(t *testing.T) {
  filet.File(t, "conf.yaml", "") // Creates a specified file

  // Creates a specified file with string "some content"
  filet.File(t, "/tmp/conf.yaml", "some content")
}

Cleaning up after yourself:

Filet lets you clean up after your files with CleanUp, which is most cleanly used at the beginning of a function with defer. For example:

func TestFoo(t *testing.T) {
  defer filet.CleanUp(t)

  // Create a bunch of temporary stuff here
}

CleanUp will call t.Error if something goes wrong when removing the file.

You can also access the Files itself if you want to add a specificly named file to the cleanup list.

filet.Files = append(filet.Files, "path/to/my/named/file")

Helpers

Filet comes with a few helper functions that are useful for working with your temporary files.

Checking Existence

You can test if a file exists if you want.

func TestFoo(t *testing.T) {
  myBool := filet.Exists(t, "path/to/my/file")
}

Checking DirContains

You can test if a folder contains a file or another directory.

func TestFoo(t *testing.T) {
  myBool := filet.DirContains(t, "path/to/myFolder", "myFile")
}

Checking if a FileSays what you want

You can check if a file's contents says what you want it to with FileSays.

func TestFoo(t *testing.T) {
  myBool := filet.FileSays(t, "path/to/my/dir", []byte("my content here"))
}

filet's Issues

Fails at parallel cleanup

I like to use Filet for tests, to create temporary structures. I use the examples from your readme. Today I started running my tests in parallal (t.Parallel()), and had weird issues. It appears Filet does not support parallel testing...

Consider the following test file (main_test.go):

package main_test

import (
	"testing"
	"time"

	"github.com/Flaque/filet"
	"github.com/stretchr/testify/assert"
)

func TestMain(t *testing.T) {
	theTest(t)
}

func TestMain2(t *testing.T) {
	theTest(t)
}

func theTest(t *testing.T) {
	t.Parallel()

	defer filet.CleanUp(t)

	filet.TmpDir(t, "")

	time.Sleep(200 * time.Millisecond)
	assert.Len(t, filet.Files, 1)
}

So we have a trivially simple TmpDir being created and cleaned up, and have to test functions doing that. (It is important that we have at least two functions, since one function is never run in parallel with itself!)

When running the tests, we can control the parallelism:

$ go test -parallel 1 -count 10 main_test.go 
ok  	command-line-arguments	4.023s
$ go test -parallel 2 -count 10 main_test.go 
--- FAIL: TestMain2 (0.20s)
    main_test.go:27: 
        	Error Trace:	main_test.go:27
        	            				main_test.go:16
        	Error:      	"[/tmp/dir587929604 /tmp/dir894240147]" should have 1 item(s), but has 2
        	Test:       	TestMain2
[...]
FAIL
FAIL	command-line-arguments	2.021s
FAIL

defer filet.CleanUp(t) does not work on Windows 7

Got messages like

C:\Temp\dir578525463\dir169146209\f21.txt: The process cannot access the file because it is being used by another process.