Moves files

internal/test/doc.go

@@ -0,0 +1,2 @@
+// Package test provides helper functions for writing tests for restic.
+package test

internal/test/helpers.go

@@ -0,0 +1,203 @@
+package test
+
+import (
+	"compress/bzip2"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"restic/errors"
+	"runtime"
+	"testing"
+
+	mrand "math/rand"
+)
+
+// Assert fails the test if the condition is false.
+func Assert(tb testing.TB, condition bool, msg string, v ...interface{}) {
+	if !condition {
+		_, file, line, _ := runtime.Caller(1)
+		fmt.Printf("\033[31m%s:%d: "+msg+"\033[39m\n\n", append([]interface{}{filepath.Base(file), line}, v...)...)
+		tb.FailNow()
+	}
+}
+
+// OK fails the test if an err is not nil.
+func OK(tb testing.TB, err error) {
+	if err != nil {
+		_, file, line, _ := runtime.Caller(1)
+		fmt.Printf("\033[31m%s:%d: unexpected error: %+v\033[39m\n\n", filepath.Base(file), line, err)
+		tb.FailNow()
+	}
+}
+
+// OKs fails the test if any error from errs is not nil.
+func OKs(tb testing.TB, errs []error) {
+	errFound := false
+	for _, err := range errs {
+		if err != nil {
+			errFound = true
+			_, file, line, _ := runtime.Caller(1)
+			fmt.Printf("\033[31m%s:%d: unexpected error: %+v\033[39m\n\n", filepath.Base(file), line, err.Error())
+		}
+	}
+	if errFound {
+		tb.FailNow()
+	}
+}
+
+// Equals fails the test if exp is not equal to act.
+func Equals(tb testing.TB, exp, act interface{}) {
+	if !reflect.DeepEqual(exp, act) {
+		_, file, line, _ := runtime.Caller(1)
+		fmt.Printf("\033[31m%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\033[39m\n\n", filepath.Base(file), line, exp, act)
+		tb.FailNow()
+	}
+}
+
+// Random returns size bytes of pseudo-random data derived from the seed.
+func Random(seed, count int) []byte {
+	p := make([]byte, count)
+
+	rnd := mrand.New(mrand.NewSource(int64(seed)))
+
+	for i := 0; i < len(p); i += 8 {
+		val := rnd.Int63()
+		var data = []byte{
+			byte((val >> 0) & 0xff),
+			byte((val >> 8) & 0xff),
+			byte((val >> 16) & 0xff),
+			byte((val >> 24) & 0xff),
+			byte((val >> 32) & 0xff),
+			byte((val >> 40) & 0xff),
+			byte((val >> 48) & 0xff),
+			byte((val >> 56) & 0xff),
+		}
+
+		for j := range data {
+			cur := i + j
+			if cur >= len(p) {
+				break
+			}
+			p[cur] = data[j]
+		}
+	}
+
+	return p
+}
+
+// SetupTarTestFixture extracts the tarFile to outputDir.
+func SetupTarTestFixture(t testing.TB, outputDir, tarFile string) {
+	input, err := os.Open(tarFile)
+	defer input.Close()
+	OK(t, err)
+
+	var rd io.Reader
+	switch filepath.Ext(tarFile) {
+	case ".gz":
+		r, err := gzip.NewReader(input)
+		OK(t, err)
+
+		defer r.Close()
+		rd = r
+	case ".bzip2":
+		rd = bzip2.NewReader(input)
+	default:
+		rd = input
+	}
+
+	cmd := exec.Command("tar", "xf", "-")
+	cmd.Dir = outputDir
+
+	cmd.Stdin = rd
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	OK(t, cmd.Run())
+}
+
+// Env creates a test environment and extracts the repository fixture.
+// Returned is the repo path and a cleanup function.
+func Env(t testing.TB, repoFixture string) (repodir string, cleanup func()) {
+	tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-env-")
+	OK(t, err)
+
+	fd, err := os.Open(repoFixture)
+	if err != nil {
+		t.Fatal(err)
+	}
+	OK(t, fd.Close())
+
+	SetupTarTestFixture(t, tempdir, repoFixture)
+
+	return filepath.Join(tempdir, "repo"), func() {
+		if !TestCleanupTempDirs {
+			t.Logf("leaving temporary directory %v used for test", tempdir)
+			return
+		}
+
+		RemoveAll(t, tempdir)
+	}
+}
+
+func isFile(fi os.FileInfo) bool {
+	return fi.Mode()&(os.ModeType|os.ModeCharDevice) == 0
+}
+
+// ResetReadOnly recursively resets the read-only flag recursively for dir.
+// This is mainly used for tests on Windows, which is unable to delete a file
+// set read-only.
+func ResetReadOnly(t testing.TB, dir string) {
+	err := filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
+		if fi == nil {
+			return err
+		}
+
+		if fi.IsDir() {
+			return os.Chmod(path, 0777)
+		}
+
+		if isFile(fi) {
+			return os.Chmod(path, 0666)
+		}
+
+		return nil
+	})
+	if os.IsNotExist(errors.Cause(err)) {
+		err = nil
+	}
+	OK(t, err)
+}
+
+// RemoveAll recursively resets the read-only flag of all files and dirs and
+// afterwards uses os.RemoveAll() to remove the path.
+func RemoveAll(t testing.TB, path string) {
+	ResetReadOnly(t, path)
+	err := os.RemoveAll(path)
+	if os.IsNotExist(errors.Cause(err)) {
+		err = nil
+	}
+	OK(t, err)
+}
+
+// TempDir returns a temporary directory that is removed when cleanup is
+// called, except if TestCleanupTempDirs is set to false.
+func TempDir(t testing.TB) (path string, cleanup func()) {
+	tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return tempdir, func() {
+		if !TestCleanupTempDirs {
+			t.Logf("leaving temporary directory %v used for test", tempdir)
+			return
+		}
+
+		RemoveAll(t, tempdir)
+	}
+}

internal/test/vars.go

@@ -0,0 +1,57 @@
+package test
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+var (
+	TestPassword                = getStringVar("RESTIC_TEST_PASSWORD", "geheim")
+	TestCleanupTempDirs         = getBoolVar("RESTIC_TEST_CLEANUP", true)
+	TestTempDir                 = getStringVar("RESTIC_TEST_TMPDIR", "")
+	RunIntegrationTest          = getBoolVar("RESTIC_TEST_INTEGRATION", true)
+	RunFuseTest                 = getBoolVar("RESTIC_TEST_FUSE", true)
+	TestSFTPPath                = getStringVar("RESTIC_TEST_SFTPPATH", "/usr/lib/ssh:/usr/lib/openssh:/usr/libexec")
+	TestWalkerPath              = getStringVar("RESTIC_TEST_PATH", ".")
+	BenchArchiveDirectory       = getStringVar("RESTIC_BENCH_DIR", ".")
+	TestS3Server                = getStringVar("RESTIC_TEST_S3_SERVER", "")
+	TestRESTServer              = getStringVar("RESTIC_TEST_REST_SERVER", "")
+	TestIntegrationDisallowSkip = getStringVar("RESTIC_TEST_DISALLOW_SKIP", "")
+)
+
+func getStringVar(name, defaultValue string) string {
+	if e := os.Getenv(name); e != "" {
+		return e
+	}
+
+	return defaultValue
+}
+
+func getBoolVar(name string, defaultValue bool) bool {
+	if e := os.Getenv(name); e != "" {
+		switch e {
+		case "1":
+			return true
+		case "0":
+			return false
+		default:
+			fmt.Fprintf(os.Stderr, "invalid value for variable %q, using default\n", name)
+		}
+	}
+
+	return defaultValue
+}
+
+// SkipDisallowed fails the test if it needs to run. The environment
+// variable RESTIC_TEST_DISALLOW_SKIP contains a comma-separated list of test
+// names that must be run. If name is in this list, the test is marked as
+// failed.
+func SkipDisallowed(t testing.TB, name string) {
+	for _, s := range strings.Split(TestIntegrationDisallowSkip, ",") {
+		if s == name {
+			t.Fatalf("test %v is in list of tests that need to run ($RESTIC_TEST_DISALLOW_SKIP)", name)
+		}
+	}
+}