From 3473c3f7b6f9012994d4f330622177d34cc0848a Mon Sep 17 00:00:00 2001 From: Herbert Date: Mon, 2 Oct 2017 15:06:39 +0200 Subject: [PATCH] Remove all dot-imports --- cmd/restic/integration_fuse_test.go | 36 +-- cmd/restic/integration_helpers_test.go | 22 +- cmd/restic/integration_test.go | 323 ++++++++++++------------ cmd/restic/local_layout_test.go | 8 +- internal/archiver/archiver_test.go | 50 ++-- internal/backend/azure/azure_test.go | 4 +- internal/backend/b2/b2_test.go | 4 +- internal/backend/gs/gs_test.go | 4 +- internal/backend/layout_test.go | 20 +- internal/backend/local/layout_test.go | 8 +- internal/backend/local/local_test.go | 10 +- internal/backend/rest/rest_test.go | 10 +- internal/backend/s3/s3_test.go | 8 +- internal/backend/sftp/layout_test.go | 8 +- internal/backend/sftp/sftp_test.go | 13 +- internal/backend/swift/swift_test.go | 9 +- internal/backend/utils_test.go | 20 +- internal/crypto/crypto_test.go | 54 ++-- internal/fuse/file_test.go | 28 +- internal/pack/pack_test.go | 32 +-- internal/pipe/pipe_test.go | 92 +++---- internal/repository/index_test.go | 88 +++---- internal/repository/parallel_test.go | 6 +- internal/repository/repository_test.go | 112 ++++---- internal/restic/config_test.go | 12 +- internal/restic/hardlinks_index_test.go | 12 +- internal/restic/lock_test.go | 90 +++---- internal/restic/node_test.go | 40 +-- internal/restic/snapshot_test.go | 4 +- internal/restic/tree_test.go | 38 +-- internal/walk/walk_test.go | 34 +-- 31 files changed, 598 insertions(+), 601 deletions(-) diff --git a/cmd/restic/integration_fuse_test.go b/cmd/restic/integration_fuse_test.go index 0a3bde4dc..1a65d803b 100644 --- a/cmd/restic/integration_fuse_test.go +++ b/cmd/restic/integration_fuse_test.go @@ -13,7 +13,7 @@ import ( "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + "github.com/restic/restic/internal/test" ) const ( @@ -56,7 +56,7 @@ func waitForMount(t testing.TB, dir string) { func testRunMount(t testing.TB, gopts GlobalOptions, dir string) { opts := MountOptions{} - OK(t, runMount(opts, gopts, []string{dir})) + test.OK(t, runMount(opts, gopts, []string{dir})) } func testRunUmount(t testing.TB, gopts GlobalOptions, dir string) { @@ -75,10 +75,10 @@ func testRunUmount(t testing.TB, gopts GlobalOptions, dir string) { func listSnapshots(t testing.TB, dir string) []string { snapshotsDir, err := os.Open(filepath.Join(dir, "snapshots")) - OK(t, err) + test.OK(t, err) names, err := snapshotsDir.Readdirnames(-1) - OK(t, err) - OK(t, snapshotsDir.Close()) + test.OK(t, err) + test.OK(t, snapshotsDir.Close()) return names } @@ -98,7 +98,7 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit namesInSnapshots := listSnapshots(t, mountpoint) t.Logf("found %v snapshots in fuse mount: %v", len(namesInSnapshots), namesInSnapshots) - Assert(t, + test.Assert(t, expectedSnapshotsInFuseDir == len(namesInSnapshots), "Invalid number of snapshots: expected %d, got %d", expectedSnapshotsInFuseDir, len(namesInSnapshots)) @@ -119,7 +119,7 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit for _, id := range snapshotIDs { snapshot, err := restic.LoadSnapshot(context.TODO(), repo, id) - OK(t, err) + test.OK(t, err) ts := snapshot.Time.Format(time.RFC3339) present, ok := namesMap[ts] @@ -143,12 +143,12 @@ func checkSnapshots(t testing.TB, global GlobalOptions, repo *repository.Reposit } for name, present := range namesMap { - Assert(t, present, "Directory %s is present in fuse dir but is not a snapshot", name) + test.Assert(t, present, "Directory %s is present in fuse dir but is not a snapshot", name) } } func TestMount(t *testing.T) { - if !RunFuseTest { + if !test.RunFuseTest { t.Skip("Skipping fuse tests") } @@ -158,19 +158,19 @@ func TestMount(t *testing.T) { testRunInit(t, env.gopts) repo, err := OpenRepository(env.gopts) - OK(t, err) + test.OK(t, err) // We remove the mountpoint now to check that cmdMount creates it - RemoveAll(t, env.mountpoint) + test.RemoveAll(t, env.mountpoint) checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, []restic.ID{}, 0) - SetupTarTestFixture(t, env.testdata, filepath.Join("testdata", "backup-data.tar.gz")) + test.SetupTarTestFixture(t, env.testdata, filepath.Join("testdata", "backup-data.tar.gz")) // first backup testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts) snapshotIDs := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 1, + test.Assert(t, len(snapshotIDs) == 1, "expected one snapshot, got %v", snapshotIDs) checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 2) @@ -178,7 +178,7 @@ func TestMount(t *testing.T) { // second backup, implicit incremental testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts) snapshotIDs = testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 2, + test.Assert(t, len(snapshotIDs) == 2, "expected two snapshots, got %v", snapshotIDs) checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 3) @@ -187,24 +187,24 @@ func TestMount(t *testing.T) { bopts := BackupOptions{Parent: snapshotIDs[0].String()} testRunBackup(t, []string{env.testdata}, bopts, env.gopts) snapshotIDs = testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 3, + test.Assert(t, len(snapshotIDs) == 3, "expected three snapshots, got %v", snapshotIDs) checkSnapshots(t, env.gopts, repo, env.mountpoint, env.repo, snapshotIDs, 4) } func TestMountSameTimestamps(t *testing.T) { - if !RunFuseTest { + if !test.RunFuseTest { t.Skip("Skipping fuse tests") } env, cleanup := withTestEnvironment(t) defer cleanup() - SetupTarTestFixture(t, env.base, filepath.Join("testdata", "repo-same-timestamps.tar.gz")) + test.SetupTarTestFixture(t, env.base, filepath.Join("testdata", "repo-same-timestamps.tar.gz")) repo, err := OpenRepository(env.gopts) - OK(t, err) + test.OK(t, err) ids := []restic.ID{ restic.TestParseID("280303689e5027328889a06d718b729e96a1ce6ae9ef8290bff550459ae611ee"), diff --git a/cmd/restic/integration_helpers_test.go b/cmd/restic/integration_helpers_test.go index 305929b6a..954a6dae4 100644 --- a/cmd/restic/integration_helpers_test.go +++ b/cmd/restic/integration_helpers_test.go @@ -11,7 +11,7 @@ import ( "github.com/restic/restic/internal/options" "github.com/restic/restic/internal/repository" - . "github.com/restic/restic/internal/test" + "github.com/restic/restic/internal/test" ) type dirEntry struct { @@ -174,14 +174,14 @@ type testEnvironment struct { // withTestEnvironment creates a test environment and returns a cleanup // function which removes it. func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) { - if !RunIntegrationTest { + if !test.RunIntegrationTest { t.Skip("integration tests disabled") } repository.TestUseLowSecurityKDFParameters(t) - tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-") - OK(t, err) + tempdir, err := ioutil.TempDir(test.TestTempDir, "restic-test-") + test.OK(t, err) env = &testEnvironment{ base: tempdir, @@ -191,17 +191,17 @@ func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) { mountpoint: filepath.Join(tempdir, "mount"), } - OK(t, os.MkdirAll(env.mountpoint, 0700)) - OK(t, os.MkdirAll(env.testdata, 0700)) - OK(t, os.MkdirAll(env.cache, 0700)) - OK(t, os.MkdirAll(env.repo, 0700)) + test.OK(t, os.MkdirAll(env.mountpoint, 0700)) + test.OK(t, os.MkdirAll(env.testdata, 0700)) + test.OK(t, os.MkdirAll(env.cache, 0700)) + test.OK(t, os.MkdirAll(env.repo, 0700)) env.gopts = GlobalOptions{ Repo: env.repo, Quiet: true, CacheDir: env.cache, ctx: context.Background(), - password: TestPassword, + password: test.TestPassword, stdout: os.Stdout, stderr: os.Stderr, extended: make(options.Options), @@ -211,11 +211,11 @@ func withTestEnvironment(t testing.TB) (env *testEnvironment, cleanup func()) { globalOptions = env.gopts cleanup = func() { - if !TestCleanupTempDirs { + if !test.TestCleanupTempDirs { t.Logf("leaving temporary directory %v used for test", tempdir) return } - RemoveAll(t, tempdir) + test.RemoveAll(t, tempdir) } return env, cleanup diff --git a/cmd/restic/integration_test.go b/cmd/restic/integration_test.go index 449b1c93e..86e4bbf5e 100644 --- a/cmd/restic/integration_test.go +++ b/cmd/restic/integration_test.go @@ -17,13 +17,12 @@ import ( "testing" "time" - "github.com/restic/restic/internal/errors" - "github.com/restic/restic/internal/restic" - "github.com/restic/restic/internal/debug" + "github.com/restic/restic/internal/errors" "github.com/restic/restic/internal/filter" "github.com/restic/restic/internal/repository" - . "github.com/restic/restic/internal/test" + "github.com/restic/restic/internal/restic" + "github.com/restic/restic/internal/test" ) func parseIDsFromReader(t testing.TB, rd io.Reader) restic.IDs { @@ -47,13 +46,13 @@ func testRunInit(t testing.TB, opts GlobalOptions) { repository.TestUseLowSecurityKDFParameters(t) restic.TestSetLockTimeout(t, 0) - OK(t, runInit(opts, nil)) + test.OK(t, runInit(opts, nil)) t.Logf("repository initialized at %v", opts.Repo) } func testRunBackup(t testing.TB, target []string, opts BackupOptions, gopts GlobalOptions) { t.Logf("backing up %v", target) - OK(t, runBackup(opts, gopts, target)) + test.OK(t, runBackup(opts, gopts, target)) } func testRunList(t testing.TB, tpe string, opts GlobalOptions) restic.IDs { @@ -63,7 +62,7 @@ func testRunList(t testing.TB, tpe string, opts GlobalOptions) restic.IDs { globalOptions.stdout = os.Stdout }() - OK(t, runList(opts, []string{tpe})) + test.OK(t, runList(opts, []string{tpe})) return parseIDsFromReader(t, buf) } @@ -78,7 +77,7 @@ func testRunRestoreLatest(t testing.TB, gopts GlobalOptions, dir string, paths [ Paths: paths, } - OK(t, runRestore(opts, gopts, []string{"latest"})) + test.OK(t, runRestore(opts, gopts, []string{"latest"})) } func testRunRestoreExcludes(t testing.TB, gopts GlobalOptions, dir string, snapshotID restic.ID, excludes []string) { @@ -87,7 +86,7 @@ func testRunRestoreExcludes(t testing.TB, gopts GlobalOptions, dir string, snaps Exclude: excludes, } - OK(t, runRestore(opts, gopts, []string{snapshotID.String()})) + test.OK(t, runRestore(opts, gopts, []string{snapshotID.String()})) } func testRunRestoreIncludes(t testing.TB, gopts GlobalOptions, dir string, snapshotID restic.ID, includes []string) { @@ -96,7 +95,7 @@ func testRunRestoreIncludes(t testing.TB, gopts GlobalOptions, dir string, snaps Include: includes, } - OK(t, runRestore(opts, gopts, []string{snapshotID.String()})) + test.OK(t, runRestore(opts, gopts, []string{snapshotID.String()})) } func testRunCheck(t testing.TB, gopts GlobalOptions) { @@ -104,7 +103,7 @@ func testRunCheck(t testing.TB, gopts GlobalOptions) { ReadData: true, CheckUnused: true, } - OK(t, runCheck(opts, gopts, nil)) + test.OK(t, runCheck(opts, gopts, nil)) } func testRunCheckOutput(gopts GlobalOptions) (string, error) { @@ -129,7 +128,7 @@ func testRunRebuildIndex(t testing.TB, gopts GlobalOptions) { globalOptions.stdout = os.Stdout }() - OK(t, runRebuildIndex(gopts)) + test.OK(t, runRebuildIndex(gopts)) } func testRunLs(t testing.TB, gopts GlobalOptions, snapshotID string) []string { @@ -144,7 +143,7 @@ func testRunLs(t testing.TB, gopts GlobalOptions, snapshotID string) []string { opts := LsOptions{} - OK(t, runLs(opts, gopts, []string{snapshotID})) + test.OK(t, runLs(opts, gopts, []string{snapshotID})) return strings.Split(string(buf.Bytes()), "\n") } @@ -160,7 +159,7 @@ func testRunFind(t testing.TB, wantJSON bool, gopts GlobalOptions, pattern strin opts := FindOptions{} - OK(t, runFind(opts, gopts, []string{pattern})) + test.OK(t, runFind(opts, gopts, []string{pattern})) return buf.Bytes() } @@ -176,10 +175,10 @@ func testRunSnapshots(t testing.TB, gopts GlobalOptions) (newest *Snapshot, snap opts := SnapshotOptions{} - OK(t, runSnapshots(opts, globalOptions, []string{})) + test.OK(t, runSnapshots(opts, globalOptions, []string{})) snapshots := []Snapshot{} - OK(t, json.Unmarshal(buf.Bytes(), &snapshots)) + test.OK(t, json.Unmarshal(buf.Bytes(), &snapshots)) snapmap = make(map[restic.ID]Snapshot, len(snapshots)) for _, sn := range snapshots { @@ -193,11 +192,11 @@ func testRunSnapshots(t testing.TB, gopts GlobalOptions) (newest *Snapshot, snap func testRunForget(t testing.TB, gopts GlobalOptions, args ...string) { opts := ForgetOptions{} - OK(t, runForget(opts, gopts, args)) + test.OK(t, runForget(opts, gopts, args)) } func testRunPrune(t testing.TB, gopts GlobalOptions) { - OK(t, runPrune(gopts)) + test.OK(t, runPrune(gopts)) } func TestBackup(t *testing.T) { @@ -210,18 +209,18 @@ func TestBackup(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) opts := BackupOptions{} // first backup testRunBackup(t, []string{env.testdata}, opts, env.gopts) snapshotIDs := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 1, + test.Assert(t, len(snapshotIDs) == 1, "expected one snapshot, got %v", snapshotIDs) testRunCheck(t, env.gopts) @@ -230,7 +229,7 @@ func TestBackup(t *testing.T) { // second backup, implicit incremental testRunBackup(t, []string{env.testdata}, opts, env.gopts) snapshotIDs = testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 2, + test.Assert(t, len(snapshotIDs) == 2, "expected two snapshots, got %v", snapshotIDs) stat2 := dirStats(env.repo) @@ -244,7 +243,7 @@ func TestBackup(t *testing.T) { opts.Parent = snapshotIDs[0].String() testRunBackup(t, []string{env.testdata}, opts, env.gopts) snapshotIDs = testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 3, + test.Assert(t, len(snapshotIDs) == 3, "expected three snapshots, got %v", snapshotIDs) stat3 := dirStats(env.repo) @@ -258,7 +257,7 @@ func TestBackup(t *testing.T) { restoredir := filepath.Join(env.base, fmt.Sprintf("restore%d", i)) t.Logf("restoring snapshot %v to %v", snapshotID.Str(), restoredir) testRunRestore(t, env.gopts, restoredir, snapshotIDs[0]) - Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")), + test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")), "directories are not equal") } @@ -275,10 +274,10 @@ func TestBackupNonExistingFile(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunInit(t, env.gopts) globalOptions.stderr = ioutil.Discard @@ -309,10 +308,10 @@ func TestBackupMissingFile1(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunInit(t, env.gopts) globalOptions.stderr = ioutil.Discard @@ -331,7 +330,7 @@ func TestBackupMissingFile1(t *testing.T) { t.Logf("in hook, removing test file testdata/0/0/9/37") ranHook = true - OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37"))) + test.OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37"))) }) opts := BackupOptions{} @@ -339,7 +338,7 @@ func TestBackupMissingFile1(t *testing.T) { testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) - Assert(t, ranHook, "hook did not run") + test.Assert(t, ranHook, "hook did not run") debug.RemoveHook("pipe.walk1") } @@ -353,10 +352,10 @@ func TestBackupMissingFile2(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunInit(t, env.gopts) @@ -376,7 +375,7 @@ func TestBackupMissingFile2(t *testing.T) { t.Logf("in hook, removing test file testdata/0/0/9/37") ranHook = true - OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37"))) + test.OK(t, os.Remove(filepath.Join(env.testdata, "0", "0", "9", "37"))) }) opts := BackupOptions{} @@ -384,7 +383,7 @@ func TestBackupMissingFile2(t *testing.T) { testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) - Assert(t, ranHook, "hook did not run") + test.Assert(t, ranHook, "hook did not run") debug.RemoveHook("pipe.walk2") } @@ -398,10 +397,10 @@ func TestBackupChangedFile(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunInit(t, env.gopts) @@ -423,7 +422,7 @@ func TestBackupChangedFile(t *testing.T) { t.Logf("in hook, modifying test file %v", modFile) ranHook = true - OK(t, ioutil.WriteFile(modFile, []byte("modified"), 0600)) + test.OK(t, ioutil.WriteFile(modFile, []byte("modified"), 0600)) }) opts := BackupOptions{} @@ -431,7 +430,7 @@ func TestBackupChangedFile(t *testing.T) { testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) - Assert(t, ranHook, "hook did not run") + test.Assert(t, ranHook, "hook did not run") debug.RemoveHook("archiver.SaveFile") } @@ -445,10 +444,10 @@ func TestBackupDirectoryError(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunInit(t, env.gopts) @@ -472,22 +471,22 @@ func TestBackupDirectoryError(t *testing.T) { t.Logf("in hook, removing test file %v", testdir) ranHook = true - OK(t, os.RemoveAll(testdir)) + test.OK(t, os.RemoveAll(testdir)) }) testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0")}, BackupOptions{}, env.gopts) testRunCheck(t, env.gopts) - Assert(t, ranHook, "hook did not run") + test.Assert(t, ranHook, "hook did not run") debug.RemoveHook("pipe.walk2") snapshots := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshots) > 0, + test.Assert(t, len(snapshots) > 0, "no snapshots found in repo (%v)", datafile) files := testRunLs(t, env.gopts, snapshots[0].String()) - Assert(t, len(files) > 1, "snapshot is empty") + test.Assert(t, len(files) > 1, "snapshot is empty") } func includes(haystack []string, needle string) bool { @@ -539,13 +538,13 @@ func TestBackupExclude(t *testing.T) { for _, filename := range backupExcludeFilenames { fp := filepath.Join(datadir, filename) - OK(t, os.MkdirAll(filepath.Dir(fp), 0755)) + test.OK(t, os.MkdirAll(filepath.Dir(fp), 0755)) f, err := os.Create(fp) - OK(t, err) + test.OK(t, err) fmt.Fprintf(f, filename) - OK(t, f.Close()) + test.OK(t, f.Close()) } snapshots := make(map[string]struct{}) @@ -555,23 +554,23 @@ func TestBackupExclude(t *testing.T) { testRunBackup(t, []string{datadir}, opts, env.gopts) snapshots, snapshotID := lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts)) files := testRunLs(t, env.gopts, snapshotID) - Assert(t, includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), + test.Assert(t, includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), "expected file %q in first snapshot, but it's not included", "foo.tar.gz") opts.Excludes = []string{"*.tar.gz"} testRunBackup(t, []string{datadir}, opts, env.gopts) snapshots, snapshotID = lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts)) files = testRunLs(t, env.gopts, snapshotID) - Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), + test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), "expected file %q not in first snapshot, but it's included", "foo.tar.gz") opts.Excludes = []string{"*.tar.gz", "private/secret"} testRunBackup(t, []string{datadir}, opts, env.gopts) _, snapshotID = lastSnapshot(snapshots, loadSnapshotMap(t, env.gopts)) files = testRunLs(t, env.gopts, snapshotID) - Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), + test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "foo.tar.gz")), "expected file %q not in first snapshot, but it's included", "foo.tar.gz") - Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "private", "secret", "passwords.txt")), + test.Assert(t, !includes(files, filepath.Join(string(filepath.Separator), "testdata", "private", "secret", "passwords.txt")), "expected file %q not in first snapshot, but it's included", "passwords.txt") } @@ -612,7 +611,7 @@ func TestIncrementalBackup(t *testing.T) { datadir := filepath.Join(env.base, "testdata") testfile := filepath.Join(datadir, "testfile") - OK(t, appendRandomData(testfile, incrementalFirstWrite)) + test.OK(t, appendRandomData(testfile, incrementalFirstWrite)) opts := BackupOptions{} @@ -620,7 +619,7 @@ func TestIncrementalBackup(t *testing.T) { testRunCheck(t, env.gopts) stat1 := dirStats(env.repo) - OK(t, appendRandomData(testfile, incrementalSecondWrite)) + test.OK(t, appendRandomData(testfile, incrementalSecondWrite)) testRunBackup(t, []string{datadir}, opts, env.gopts) testRunCheck(t, env.gopts) @@ -630,7 +629,7 @@ func TestIncrementalBackup(t *testing.T) { } t.Logf("repository grown by %d bytes", stat2.size-stat1.size) - OK(t, appendRandomData(testfile, incrementalThirdWrite)) + test.OK(t, appendRandomData(testfile, incrementalThirdWrite)) testRunBackup(t, []string{datadir}, opts, env.gopts) testRunCheck(t, env.gopts) @@ -647,28 +646,28 @@ func TestBackupTags(t *testing.T) { datafile := filepath.Join("testdata", "backup-data.tar.gz") testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) opts := BackupOptions{} testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) newest, _ := testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 0, + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 0, "expected no tags, got %v", newest.Tags) opts.Tags = []string{"NL"} testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL", + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL", "expected one NL tag, got %v", newest.Tags) } func testRunTag(t testing.TB, opts TagOptions, gopts GlobalOptions) { - OK(t, runTag(opts, gopts, []string{})) + test.OK(t, runTag(opts, gopts, []string{})) } func TestTag(t *testing.T) { @@ -677,68 +676,68 @@ func TestTag(t *testing.T) { datafile := filepath.Join("testdata", "backup-data.tar.gz") testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) testRunBackup(t, []string{env.testdata}, BackupOptions{}, env.gopts) testRunCheck(t, env.gopts) newest, _ := testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 0, + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 0, "expected no tags, got %v", newest.Tags) - Assert(t, newest.Original == nil, + test.Assert(t, newest.Original == nil, "expected original ID to be nil, got %v", newest.Original) originalID := *newest.ID testRunTag(t, TagOptions{SetTags: []string{"NL"}}, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL", + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "NL", "set failed, expected one NL tag, got %v", newest.Tags) - Assert(t, newest.Original != nil, "expected original snapshot id, got nil") - Assert(t, *newest.Original == originalID, + test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil") + test.Assert(t, *newest.Original == originalID, "expected original ID to be set to the first snapshot id") testRunTag(t, TagOptions{AddTags: []string{"CH"}}, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 2 && newest.Tags[0] == "NL" && newest.Tags[1] == "CH", + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 2 && newest.Tags[0] == "NL" && newest.Tags[1] == "CH", "add failed, expected CH,NL tags, got %v", newest.Tags) - Assert(t, newest.Original != nil, "expected original snapshot id, got nil") - Assert(t, *newest.Original == originalID, + test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil") + test.Assert(t, *newest.Original == originalID, "expected original ID to be set to the first snapshot id") testRunTag(t, TagOptions{RemoveTags: []string{"NL"}}, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "CH", + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 1 && newest.Tags[0] == "CH", "remove failed, expected one CH tag, got %v", newest.Tags) - Assert(t, newest.Original != nil, "expected original snapshot id, got nil") - Assert(t, *newest.Original == originalID, + test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil") + test.Assert(t, *newest.Original == originalID, "expected original ID to be set to the first snapshot id") testRunTag(t, TagOptions{AddTags: []string{"US", "RU"}}, env.gopts) testRunTag(t, TagOptions{RemoveTags: []string{"CH", "US", "RU"}}, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 0, + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 0, "expected no tags, got %v", newest.Tags) - Assert(t, newest.Original != nil, "expected original snapshot id, got nil") - Assert(t, *newest.Original == originalID, + test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil") + test.Assert(t, *newest.Original == originalID, "expected original ID to be set to the first snapshot id") // Check special case of removing all tags. testRunTag(t, TagOptions{SetTags: []string{""}}, env.gopts) testRunCheck(t, env.gopts) newest, _ = testRunSnapshots(t, env.gopts) - Assert(t, newest != nil, "expected a new backup, got nil") - Assert(t, len(newest.Tags) == 0, + test.Assert(t, newest != nil, "expected a new backup, got nil") + test.Assert(t, len(newest.Tags) == 0, "expected no tags, got %v", newest.Tags) - Assert(t, newest.Original != nil, "expected original snapshot id, got nil") - Assert(t, *newest.Original == originalID, + test.Assert(t, newest.Original != nil, "expected original snapshot id, got nil") + test.Assert(t, *newest.Original == originalID, "expected original ID to be set to the first snapshot id") } @@ -750,7 +749,7 @@ func testRunKeyListOtherIDs(t testing.TB, gopts GlobalOptions) []string { globalOptions.stdout = os.Stdout }() - OK(t, runKey(gopts, []string{"list"})) + test.OK(t, runKey(gopts, []string{"list"})) scanner := bufio.NewScanner(buf) exp := regexp.MustCompile(`^ ([a-f0-9]+) `) @@ -771,7 +770,7 @@ func testRunKeyAddNewKey(t testing.TB, newPassword string, gopts GlobalOptions) testKeyNewPassword = "" }() - OK(t, runKey(gopts, []string{"add"})) + test.OK(t, runKey(gopts, []string{"add"})) } func testRunKeyPasswd(t testing.TB, newPassword string, gopts GlobalOptions) { @@ -780,13 +779,13 @@ func testRunKeyPasswd(t testing.TB, newPassword string, gopts GlobalOptions) { testKeyNewPassword = "" }() - OK(t, runKey(gopts, []string{"passwd"})) + test.OK(t, runKey(gopts, []string{"passwd"})) } func testRunKeyRemove(t testing.TB, gopts GlobalOptions, IDs []string) { t.Logf("remove %d keys: %q\n", len(IDs), IDs) for _, id := range IDs { - OK(t, runKey(gopts, []string{"remove", id})) + test.OK(t, runKey(gopts, []string{"remove", id})) } } @@ -814,7 +813,7 @@ func TestKeyAddRemove(t *testing.T) { env.gopts.password = passwordList[len(passwordList)-1] t.Logf("testing access with last password %q\n", env.gopts.password) - OK(t, runKey(env.gopts, []string{"list"})) + test.OK(t, runKey(env.gopts, []string{"list"})) testRunCheck(t, env.gopts) } @@ -847,10 +846,10 @@ func TestRestoreFilter(t *testing.T) { testRunInit(t, env.gopts) - for _, test := range testfiles { - p := filepath.Join(env.testdata, test.name) - OK(t, os.MkdirAll(filepath.Dir(p), 0755)) - OK(t, appendRandomData(p, test.size)) + for _, testFile := range testfiles { + p := filepath.Join(env.testdata, testFile.name) + test.OK(t, os.MkdirAll(filepath.Dir(p), 0755)) + test.OK(t, appendRandomData(p, testFile.size)) } opts := BackupOptions{} @@ -862,20 +861,20 @@ func TestRestoreFilter(t *testing.T) { // no restore filter should restore all files testRunRestore(t, env.gopts, filepath.Join(env.base, "restore0"), snapshotID) - for _, test := range testfiles { - OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", test.name), int64(test.size))) + for _, testFile := range testfiles { + test.OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", testFile.name), int64(testFile.size))) } for i, pat := range []string{"*.c", "*.exe", "*", "*file3*"} { base := filepath.Join(env.base, fmt.Sprintf("restore%d", i+1)) testRunRestoreExcludes(t, env.gopts, base, snapshotID, []string{pat}) - for _, test := range testfiles { - err := testFileSize(filepath.Join(base, "testdata", test.name), int64(test.size)) - if ok, _ := filter.Match(pat, filepath.Base(test.name)); !ok { - OK(t, err) + for _, testFile := range testfiles { + err := testFileSize(filepath.Join(base, "testdata", testFile.name), int64(testFile.size)) + if ok, _ := filter.Match(pat, filepath.Base(testFile.name)); !ok { + test.OK(t, err) } else { - Assert(t, os.IsNotExist(errors.Cause(err)), - "expected %v to not exist in restore step %v, but it exists, err %v", test.name, i+1, err) + test.Assert(t, os.IsNotExist(errors.Cause(err)), + "expected %v to not exist in restore step %v, but it exists, err %v", testFile.name, i+1, err) } } } @@ -889,8 +888,8 @@ func TestRestore(t *testing.T) { for i := 0; i < 10; i++ { p := filepath.Join(env.testdata, fmt.Sprintf("foo/bar/testfile%v", i)) - OK(t, os.MkdirAll(filepath.Dir(p), 0755)) - OK(t, appendRandomData(p, uint(mrand.Intn(5<<21)))) + test.OK(t, os.MkdirAll(filepath.Dir(p), 0755)) + test.OK(t, appendRandomData(p, uint(mrand.Intn(5<<21)))) } opts := BackupOptions{} @@ -902,7 +901,7 @@ func TestRestore(t *testing.T) { restoredir := filepath.Join(env.base, "restore") testRunRestoreLatest(t, env.gopts, restoredir, nil, "") - Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, filepath.Base(env.testdata))), + test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, filepath.Base(env.testdata))), "directories are not equal") } @@ -913,8 +912,8 @@ func TestRestoreLatest(t *testing.T) { testRunInit(t, env.gopts) p := filepath.Join(env.testdata, "testfile.c") - OK(t, os.MkdirAll(filepath.Dir(p), 0755)) - OK(t, appendRandomData(p, 100)) + test.OK(t, os.MkdirAll(filepath.Dir(p), 0755)) + test.OK(t, appendRandomData(p, 100)) opts := BackupOptions{} @@ -922,24 +921,24 @@ func TestRestoreLatest(t *testing.T) { testRunCheck(t, env.gopts) os.Remove(p) - OK(t, appendRandomData(p, 101)) + test.OK(t, appendRandomData(p, 101)) testRunBackup(t, []string{env.testdata}, opts, env.gopts) testRunCheck(t, env.gopts) // Restore latest without any filters testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore0"), nil, "") - OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", "testfile.c"), int64(101))) + test.OK(t, testFileSize(filepath.Join(env.base, "restore0", "testdata", "testfile.c"), int64(101))) // Setup test files in different directories backed up in different snapshots p1 := filepath.Join(env.testdata, "p1/testfile.c") - OK(t, os.MkdirAll(filepath.Dir(p1), 0755)) - OK(t, appendRandomData(p1, 102)) + test.OK(t, os.MkdirAll(filepath.Dir(p1), 0755)) + test.OK(t, appendRandomData(p1, 102)) testRunBackup(t, []string{filepath.Dir(p1)}, opts, env.gopts) testRunCheck(t, env.gopts) p2 := filepath.Join(env.testdata, "p2/testfile.c") - OK(t, os.MkdirAll(filepath.Dir(p2), 0755)) - OK(t, appendRandomData(p2, 103)) + test.OK(t, os.MkdirAll(filepath.Dir(p2), 0755)) + test.OK(t, appendRandomData(p2, 103)) testRunBackup(t, []string{filepath.Dir(p2)}, opts, env.gopts) testRunCheck(t, env.gopts) @@ -947,16 +946,16 @@ func TestRestoreLatest(t *testing.T) { p2rAbs := filepath.Join(env.base, "restore2", "p2/testfile.c") testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore1"), []string{filepath.Dir(p1)}, "") - OK(t, testFileSize(p1rAbs, int64(102))) + test.OK(t, testFileSize(p1rAbs, int64(102))) if _, err := os.Stat(p2rAbs); os.IsNotExist(errors.Cause(err)) { - Assert(t, os.IsNotExist(errors.Cause(err)), + test.Assert(t, os.IsNotExist(errors.Cause(err)), "expected %v to not exist in restore, but it exists, err %v", p2rAbs, err) } testRunRestoreLatest(t, env.gopts, filepath.Join(env.base, "restore2"), []string{filepath.Dir(p2)}, "") - OK(t, testFileSize(p2rAbs, int64(103))) + test.OK(t, testFileSize(p2rAbs, int64(103))) if _, err := os.Stat(p1rAbs); os.IsNotExist(errors.Cause(err)) { - Assert(t, os.IsNotExist(errors.Cause(err)), + test.Assert(t, os.IsNotExist(errors.Cause(err)), "expected %v to not exist in restore, but it exists, err %v", p1rAbs, err) } } @@ -966,10 +965,10 @@ func TestRestoreWithPermissionFailure(t *testing.T) { defer cleanup() datafile := filepath.Join("testdata", "repo-restore-permissions-test.tar.gz") - SetupTarTestFixture(t, env.base, datafile) + test.SetupTarTestFixture(t, env.base, datafile) snapshots := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshots) > 0, + test.Assert(t, len(snapshots) > 0, "no snapshots found in repo (%v)", datafile) globalOptions.stderr = ioutil.Discard @@ -984,9 +983,9 @@ func TestRestoreWithPermissionFailure(t *testing.T) { files := testRunLs(t, env.gopts, snapshots[0].String()) for _, filename := range files { fi, err := os.Lstat(filepath.Join(env.base, "restore", filename)) - OK(t, err) + test.OK(t, err) - Assert(t, !isFile(fi) || fi.Size() > 0, + test.Assert(t, !isFile(fi) || fi.Size() > 0, "file %v restored, but filesize is 0", filename) } } @@ -1007,9 +1006,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) { testRunInit(t, env.gopts) p := filepath.Join(env.testdata, "subdir1", "subdir2", "subdir3", "file.ext") - OK(t, os.MkdirAll(filepath.Dir(p), 0755)) - OK(t, appendRandomData(p, 200)) - OK(t, setZeroModTime(filepath.Join(env.testdata, "subdir1", "subdir2"))) + test.OK(t, os.MkdirAll(filepath.Dir(p), 0755)) + test.OK(t, appendRandomData(p, 200)) + test.OK(t, setZeroModTime(filepath.Join(env.testdata, "subdir1", "subdir2"))) opts := BackupOptions{} @@ -1025,9 +1024,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) { f1 := filepath.Join(env.base, "restore0", "testdata", "subdir1", "subdir2") fi, err := os.Stat(f1) - OK(t, err) + test.OK(t, err) - Assert(t, fi.ModTime() != time.Unix(0, 0), + test.Assert(t, fi.ModTime() != time.Unix(0, 0), "meta data of intermediate directory has been restore although it was ignored") // restore with filter "*", this should restore meta data on everything. @@ -1035,9 +1034,9 @@ func TestRestoreNoMetadataOnIgnoredIntermediateDirs(t *testing.T) { f2 := filepath.Join(env.base, "restore1", "testdata", "subdir1", "subdir2") fi, err = os.Stat(f2) - OK(t, err) + test.OK(t, err) - Assert(t, fi.ModTime() == time.Unix(0, 0), + test.Assert(t, fi.ModTime() == time.Unix(0, 0), "meta data of intermediate directory hasn't been restore") } @@ -1047,7 +1046,7 @@ func TestFind(t *testing.T) { datafile := filepath.Join("testdata", "backup-data.tar.gz") testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) opts := BackupOptions{} @@ -1055,15 +1054,15 @@ func TestFind(t *testing.T) { testRunCheck(t, env.gopts) results := testRunFind(t, false, env.gopts, "unexistingfile") - Assert(t, len(results) == 0, "unexisting file found in repo (%v)", datafile) + test.Assert(t, len(results) == 0, "unexisting file found in repo (%v)", datafile) results = testRunFind(t, false, env.gopts, "testfile") lines := strings.Split(string(results), "\n") - Assert(t, len(lines) == 2, "expected one file found in repo (%v)", datafile) + test.Assert(t, len(lines) == 2, "expected one file found in repo (%v)", datafile) results = testRunFind(t, false, env.gopts, "testfile*") lines = strings.Split(string(results), "\n") - Assert(t, len(lines) == 4, "expected three files found in repo (%v)", datafile) + test.Assert(t, len(lines) == 4, "expected three files found in repo (%v)", datafile) } type testMatch struct { @@ -1087,7 +1086,7 @@ func TestFindJSON(t *testing.T) { datafile := filepath.Join("testdata", "backup-data.tar.gz") testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) opts := BackupOptions{} @@ -1096,20 +1095,20 @@ func TestFindJSON(t *testing.T) { results := testRunFind(t, true, env.gopts, "unexistingfile") matches := []testMatches{} - OK(t, json.Unmarshal(results, &matches)) - Assert(t, len(matches) == 0, "expected no match in repo (%v)", datafile) + test.OK(t, json.Unmarshal(results, &matches)) + test.Assert(t, len(matches) == 0, "expected no match in repo (%v)", datafile) results = testRunFind(t, true, env.gopts, "testfile") - OK(t, json.Unmarshal(results, &matches)) - Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile) - Assert(t, len(matches[0].Matches) == 1, "expected a single file to match (%v)", datafile) - Assert(t, matches[0].Hits == 1, "expected hits to show 1 match (%v)", datafile) + test.OK(t, json.Unmarshal(results, &matches)) + test.Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile) + test.Assert(t, len(matches[0].Matches) == 1, "expected a single file to match (%v)", datafile) + test.Assert(t, matches[0].Hits == 1, "expected hits to show 1 match (%v)", datafile) results = testRunFind(t, true, env.gopts, "testfile*") - OK(t, json.Unmarshal(results, &matches)) - Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile) - Assert(t, len(matches[0].Matches) == 3, "expected 3 files to match (%v)", datafile) - Assert(t, matches[0].Hits == 3, "expected hits to show 3 matches (%v)", datafile) + test.OK(t, json.Unmarshal(results, &matches)) + test.Assert(t, len(matches) == 1, "expected a single snapshot in repo (%v)", datafile) + test.Assert(t, len(matches[0].Matches) == 3, "expected 3 files to match (%v)", datafile) + test.Assert(t, matches[0].Hits == 3, "expected hits to show 3 matches (%v)", datafile) } func TestRebuildIndex(t *testing.T) { @@ -1117,7 +1116,7 @@ func TestRebuildIndex(t *testing.T) { defer cleanup() datafile := filepath.Join("..", "..", "internal", "checker", "testdata", "duplicate-packs-in-index-test-repo.tar.gz") - SetupTarTestFixture(t, env.base, datafile) + test.SetupTarTestFixture(t, env.base, datafile) out, err := testRunCheckOutput(env.gopts) if !strings.Contains(out, "contained in several indexes") { @@ -1154,7 +1153,7 @@ func TestCheckRestoreNoLock(t *testing.T) { defer cleanup() datafile := filepath.Join("testdata", "small-repo.tar.gz") - SetupTarTestFixture(t, env.base, datafile) + test.SetupTarTestFixture(t, env.base, datafile) err := filepath.Walk(env.repo, func(p string, fi os.FileInfo, e error) error { if e != nil { @@ -1162,7 +1161,7 @@ func TestCheckRestoreNoLock(t *testing.T) { } return os.Chmod(p, fi.Mode() & ^(os.FileMode(0222))) }) - OK(t, err) + test.OK(t, err) env.gopts.NoLock = true @@ -1186,24 +1185,24 @@ func TestPrune(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) opts := BackupOptions{} testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0")}, opts, env.gopts) firstSnapshot := testRunList(t, "snapshots", env.gopts) - Assert(t, len(firstSnapshot) == 1, + test.Assert(t, len(firstSnapshot) == 1, "expected one snapshot, got %v", firstSnapshot) testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0", "2")}, opts, env.gopts) testRunBackup(t, []string{filepath.Join(env.testdata, "0", "0", "3")}, opts, env.gopts) snapshotIDs := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 3, + test.Assert(t, len(snapshotIDs) == 3, "expected 3 snapshot, got %v", snapshotIDs) testRunForget(t, env.gopts, firstSnapshot[0].String()) @@ -1222,12 +1221,12 @@ func TestHardLink(t *testing.T) { t.Skipf("unable to find data file %q, skipping", datafile) return } - OK(t, err) - OK(t, fd.Close()) + test.OK(t, err) + test.OK(t, fd.Close()) testRunInit(t, env.gopts) - SetupTarTestFixture(t, env.testdata, datafile) + test.SetupTarTestFixture(t, env.testdata, datafile) linkTests := createFileSetPerHardlink(env.testdata) @@ -1236,7 +1235,7 @@ func TestHardLink(t *testing.T) { // first backup testRunBackup(t, []string{env.testdata}, opts, env.gopts) snapshotIDs := testRunList(t, "snapshots", env.gopts) - Assert(t, len(snapshotIDs) == 1, + test.Assert(t, len(snapshotIDs) == 1, "expected one snapshot, got %v", snapshotIDs) testRunCheck(t, env.gopts) @@ -1246,11 +1245,11 @@ func TestHardLink(t *testing.T) { restoredir := filepath.Join(env.base, fmt.Sprintf("restore%d", i)) t.Logf("restoring snapshot %v to %v", snapshotID.Str(), restoredir) testRunRestore(t, env.gopts, restoredir, snapshotIDs[0]) - Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")), + test.Assert(t, directoriesEqualContents(env.testdata, filepath.Join(restoredir, "testdata")), "directories are not equal") linkResults := createFileSetPerHardlink(filepath.Join(restoredir, "testdata")) - Assert(t, linksEqual(linkTests, linkResults), + test.Assert(t, linksEqual(linkTests, linkResults), "links are not equal") } diff --git a/cmd/restic/local_layout_test.go b/cmd/restic/local_layout_test.go index 4d22342ee..c76112e00 100644 --- a/cmd/restic/local_layout_test.go +++ b/cmd/restic/local_layout_test.go @@ -4,7 +4,7 @@ import ( "path/filepath" "testing" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestRestoreLocalLayout(t *testing.T) { @@ -24,7 +24,7 @@ func TestRestoreLocalLayout(t *testing.T) { for _, test := range tests { datafile := filepath.Join("..", "..", "internal", "backend", "testdata", test.filename) - SetupTarTestFixture(t, env.base, datafile) + rtest.SetupTarTestFixture(t, env.base, datafile) env.gopts.extended["local.layout"] = test.layout @@ -35,7 +35,7 @@ func TestRestoreLocalLayout(t *testing.T) { target := filepath.Join(env.base, "restore") testRunRestoreLatest(t, env.gopts, target, nil, "") - RemoveAll(t, filepath.Join(env.base, "repo")) - RemoveAll(t, target) + rtest.RemoveAll(t, filepath.Join(env.base, "repo")) + rtest.RemoveAll(t, target) } } diff --git a/internal/archiver/archiver_test.go b/internal/archiver/archiver_test.go index cc29ae330..01e9d9e74 100644 --- a/internal/archiver/archiver_test.go +++ b/internal/archiver/archiver_test.go @@ -15,7 +15,7 @@ import ( "github.com/restic/restic/internal/crypto" "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" "github.com/restic/restic/internal/errors" @@ -40,14 +40,14 @@ func benchmarkChunkEncrypt(b testing.TB, buf, buf2 []byte, rd Rdr, key *crypto.K break } - OK(b, err) + rtest.OK(b, err) // reduce length of buf - Assert(b, uint(len(chunk.Data)) == chunk.Length, + rtest.Assert(b, uint(len(chunk.Data)) == chunk.Length, "invalid length: got %d, expected %d", len(chunk.Data), chunk.Length) _, err = key.Encrypt(buf2, chunk.Data) - OK(b, err) + rtest.OK(b, err) } } @@ -55,7 +55,7 @@ func BenchmarkChunkEncrypt(b *testing.B) { repo, cleanup := repository.TestRepository(b) defer cleanup() - data := Random(23, 10<<20) // 10MiB + data := rtest.Random(23, 10<<20) // 10MiB rd := bytes.NewReader(data) buf := make([]byte, chunker.MaxSize) @@ -87,7 +87,7 @@ func BenchmarkChunkEncryptParallel(b *testing.B) { repo, cleanup := repository.TestRepository(b) defer cleanup() - data := Random(23, 10<<20) // 10MiB + data := rtest.Random(23, 10<<20) // 10MiB buf := make([]byte, chunker.MaxSize) @@ -108,14 +108,14 @@ func archiveDirectory(b testing.TB) { arch := archiver.New(repo) - _, id, err := arch.Snapshot(context.TODO(), nil, []string{BenchArchiveDirectory}, nil, "localhost", nil, time.Now()) - OK(b, err) + _, id, err := arch.Snapshot(context.TODO(), nil, []string{rtest.BenchArchiveDirectory}, nil, "localhost", nil, time.Now()) + rtest.OK(b, err) b.Logf("snapshot archived as %v", id) } func TestArchiveDirectory(t *testing.T) { - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { t.Skip("benchdir not set, skipping TestArchiveDirectory") } @@ -123,7 +123,7 @@ func TestArchiveDirectory(t *testing.T) { } func BenchmarkArchiveDirectory(b *testing.B) { - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { b.Skip("benchdir not set, skipping BenchmarkArchiveDirectory") } @@ -144,7 +144,7 @@ func archiveWithDedup(t testing.TB) { repo, cleanup := repository.TestRepository(t) defer cleanup() - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { t.Skip("benchdir not set, skipping TestArchiverDedup") } @@ -155,7 +155,7 @@ func archiveWithDedup(t testing.TB) { } // archive a few files - sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil) + sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil) t.Logf("archived snapshot %v", sn.ID().Str()) // get archive stats @@ -166,7 +166,7 @@ func archiveWithDedup(t testing.TB) { cnt.before.packs, cnt.before.dataBlobs, cnt.before.treeBlobs) // archive the same files again, without parent snapshot - sn2 := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil) + sn2 := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil) t.Logf("archived snapshot %v", sn2.ID().Str()) // get archive stats again @@ -183,7 +183,7 @@ func archiveWithDedup(t testing.TB) { } // archive the same files again, with a parent snapshot - sn3 := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, sn2.ID()) + sn3 := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, sn2.ID()) t.Logf("archived snapshot %v, parent %v", sn3.ID().Str(), sn2.ID().Str()) // get archive stats again @@ -246,18 +246,18 @@ func testParallelSaveWithDuplication(t *testing.T, seed int) { } for _, errChan := range errChannels { - OK(t, <-errChan) + rtest.OK(t, <-errChan) } - OK(t, repo.Flush()) - OK(t, repo.SaveIndex(context.TODO())) + rtest.OK(t, repo.Flush()) + rtest.OK(t, repo.SaveIndex(context.TODO())) chkr := createAndInitChecker(t, repo) assertNoUnreferencedPacks(t, chkr) } func getRandomData(seed int, size int) []chunker.Chunk { - buf := Random(seed, size) + buf := rtest.Random(seed, size) var chunks []chunker.Chunk chunker := chunker.New(bytes.NewReader(buf), testPol) @@ -292,7 +292,7 @@ func assertNoUnreferencedPacks(t *testing.T, chkr *checker.Checker) { go chkr.Packs(context.TODO(), errChan) for err := range errChan { - OK(t, err) + rtest.OK(t, err) } } @@ -341,26 +341,26 @@ func TestArchiveNameCollision(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - dir, cleanup := TempDir(t) + dir, cleanup := rtest.TempDir(t) defer cleanup() root := filepath.Join(dir, "root") - OK(t, os.MkdirAll(root, 0755)) + rtest.OK(t, os.MkdirAll(root, 0755)) - OK(t, ioutil.WriteFile(filepath.Join(dir, "testfile"), []byte("testfile1"), 0644)) - OK(t, ioutil.WriteFile(filepath.Join(dir, "root", "testfile"), []byte("testfile2"), 0644)) + rtest.OK(t, ioutil.WriteFile(filepath.Join(dir, "testfile"), []byte("testfile1"), 0644)) + rtest.OK(t, ioutil.WriteFile(filepath.Join(dir, "root", "testfile"), []byte("testfile2"), 0644)) defer chdir(t, root)() arch := archiver.New(repo) sn, id, err := arch.Snapshot(context.TODO(), nil, []string{"testfile", filepath.Join("..", "testfile")}, nil, "localhost", nil, time.Now()) - OK(t, err) + rtest.OK(t, err) t.Logf("snapshot archived as %v", id) tree, err := repo.LoadTree(context.TODO(), *sn.Tree) - OK(t, err) + rtest.OK(t, err) if len(tree.Nodes) != 2 { t.Fatalf("tree has %d nodes, wanted 2: %v", len(tree.Nodes), tree.Nodes) diff --git a/internal/backend/azure/azure_test.go b/internal/backend/azure/azure_test.go index 4f59e3be9..326b9152f 100644 --- a/internal/backend/azure/azure_test.go +++ b/internal/backend/azure/azure_test.go @@ -11,7 +11,7 @@ import ( "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/errors" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func newAzureTestSuite(t testing.TB) *test.Suite { @@ -81,7 +81,7 @@ func newAzureTestSuite(t testing.TB) *test.Suite { func TestBackendAzure(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/azure.TestBackendAzure") + rtest.SkipDisallowed(t, "restic/backend/azure.TestBackendAzure") } }() diff --git a/internal/backend/b2/b2_test.go b/internal/backend/b2/b2_test.go index 7fe90b0a0..9c5c57455 100644 --- a/internal/backend/b2/b2_test.go +++ b/internal/backend/b2/b2_test.go @@ -11,7 +11,7 @@ import ( "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func newB2TestSuite(t testing.TB) *test.Suite { @@ -83,7 +83,7 @@ func testVars(t testing.TB) { func TestBackendB2(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/b2.TestBackendB2") + rtest.SkipDisallowed(t, "restic/backend/b2.TestBackendB2") } }() diff --git a/internal/backend/gs/gs_test.go b/internal/backend/gs/gs_test.go index f7b412e5d..739aaacf3 100644 --- a/internal/backend/gs/gs_test.go +++ b/internal/backend/gs/gs_test.go @@ -11,7 +11,7 @@ import ( "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/errors" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func newGSTestSuite(t testing.TB) *test.Suite { @@ -81,7 +81,7 @@ func newGSTestSuite(t testing.TB) *test.Suite { func TestBackendGS(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/gs.TestBackendGS") + rtest.SkipDisallowed(t, "restic/backend/gs.TestBackendGS") } }() diff --git a/internal/backend/layout_test.go b/internal/backend/layout_test.go index 35aa4bcce..0c52b32bc 100644 --- a/internal/backend/layout_test.go +++ b/internal/backend/layout_test.go @@ -9,11 +9,11 @@ import ( "testing" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestDefaultLayout(t *testing.T) { - tempdir, cleanup := TempDir(t) + tempdir, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -140,7 +140,7 @@ func TestDefaultLayout(t *testing.T) { } func TestRESTLayout(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -286,7 +286,7 @@ func TestRESTLayoutURLs(t *testing.T) { } func TestS3LegacyLayout(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -354,7 +354,7 @@ func TestS3LegacyLayout(t *testing.T) { } func TestDetectLayout(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -369,7 +369,7 @@ func TestDetectLayout(t *testing.T) { for _, test := range tests { for _, fs := range []Filesystem{fs, nil} { t.Run(fmt.Sprintf("%v/fs-%T", test.filename, fs), func(t *testing.T) { - SetupTarTestFixture(t, path, filepath.Join("testdata", test.filename)) + rtest.SetupTarTestFixture(t, path, filepath.Join("testdata", test.filename)) layout, err := DetectLayout(fs, filepath.Join(path, "repo")) if err != nil { @@ -385,14 +385,14 @@ func TestDetectLayout(t *testing.T) { t.Fatalf("want layout %v, got %v", test.want, layoutName) } - RemoveAll(t, filepath.Join(path, "repo")) + rtest.RemoveAll(t, filepath.Join(path, "repo")) }) } } } func TestParseLayout(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -405,7 +405,7 @@ func TestParseLayout(t *testing.T) { {"", "", "*backend.DefaultLayout"}, } - SetupTarTestFixture(t, path, filepath.Join("testdata", "repo-layout-default.tar.gz")) + rtest.SetupTarTestFixture(t, path, filepath.Join("testdata", "repo-layout-default.tar.gz")) for _, test := range tests { t.Run(test.layoutName, func(t *testing.T) { @@ -432,7 +432,7 @@ func TestParseLayout(t *testing.T) { } func TestParseLayoutInvalid(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var invalidNames = []string{ diff --git a/internal/backend/local/layout_test.go b/internal/backend/local/layout_test.go index 1b2e342c7..05eba96f0 100644 --- a/internal/backend/local/layout_test.go +++ b/internal/backend/local/layout_test.go @@ -6,11 +6,11 @@ import ( "testing" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestLayout(t *testing.T) { - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -33,7 +33,7 @@ func TestLayout(t *testing.T) { for _, test := range tests { t.Run(test.filename, func(t *testing.T) { - SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename)) + rtest.SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename)) repo := filepath.Join(path, "repo") be, err := Open(Config{ @@ -75,7 +75,7 @@ func TestLayout(t *testing.T) { t.Errorf("Close() returned error %v", err) } - RemoveAll(t, filepath.Join(path, "repo")) + rtest.RemoveAll(t, filepath.Join(path, "repo")) }) } } diff --git a/internal/backend/local/local_test.go b/internal/backend/local/local_test.go index e5b1e2533..4ca3fdb71 100644 --- a/internal/backend/local/local_test.go +++ b/internal/backend/local/local_test.go @@ -9,14 +9,14 @@ import ( "github.com/restic/restic/internal/backend/local" "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func newTestSuite(t testing.TB) *test.Suite { return &test.Suite{ // NewConfig returns a config for a new temporary backend that will be used in tests. NewConfig: func() (interface{}, error) { - dir, err := ioutil.TempDir(TestTempDir, "restic-test-local-") + dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-local-") if err != nil { t.Fatal(err) } @@ -44,11 +44,11 @@ func newTestSuite(t testing.TB) *test.Suite { // CleanupFn removes data created during the tests. Cleanup: func(config interface{}) error { cfg := config.(local.Config) - if !TestCleanupTempDirs { + if !rtest.TestCleanupTempDirs { t.Logf("leaving test backend dir at %v", cfg.Path) } - RemoveAll(t, cfg.Path) + rtest.RemoveAll(t, cfg.Path) return nil }, } @@ -119,7 +119,7 @@ func removeAll(t testing.TB, dir string) { } func TestOpenNotExistingDirectory(t *testing.T) { - dir, cleanup := TempDir(t) + dir, cleanup := rtest.TempDir(t) defer cleanup() // local.Open must not create any files dirs in the repo diff --git a/internal/backend/rest/rest_test.go b/internal/backend/rest/rest_test.go index 314a5c32b..f6fbafbd6 100644 --- a/internal/backend/rest/rest_test.go +++ b/internal/backend/rest/rest_test.go @@ -13,7 +13,7 @@ import ( "github.com/restic/restic/internal/backend/rest" "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func runRESTServer(ctx context.Context, t testing.TB, dir string) func() { @@ -64,7 +64,7 @@ func newTestSuite(ctx context.Context, t testing.TB) *test.Suite { return &test.Suite{ // NewConfig returns a config for a new temporary backend that will be used in tests. NewConfig: func() (interface{}, error) { - dir, err := ioutil.TempDir(TestTempDir, "restic-test-rest-") + dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-rest-") if err != nil { t.Fatal(err) } @@ -103,14 +103,14 @@ func newTestSuite(ctx context.Context, t testing.TB) *test.Suite { func TestBackendREST(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/rest.TestBackendREST") + rtest.SkipDisallowed(t, "restic/backend/rest.TestBackendREST") } }() ctx, cancel := context.WithCancel(context.Background()) defer cancel() - dir, cleanup := TempDir(t) + dir, cleanup := rtest.TempDir(t) defer cleanup() cleanup = runRESTServer(ctx, t, dir) @@ -123,7 +123,7 @@ func BenchmarkBackendREST(t *testing.B) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - dir, cleanup := TempDir(t) + dir, cleanup := rtest.TempDir(t) defer cleanup() cleanup = runRESTServer(ctx, t, dir) diff --git a/internal/backend/s3/s3_test.go b/internal/backend/s3/s3_test.go index 19927b6ac..3cc20cc72 100644 --- a/internal/backend/s3/s3_test.go +++ b/internal/backend/s3/s3_test.go @@ -17,7 +17,7 @@ import ( "github.com/restic/restic/internal/backend/s3" "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func mkdir(t testing.TB, dir string) { @@ -124,7 +124,7 @@ func newMinioTestSuite(ctx context.Context, t testing.TB) *test.Suite { NewConfig: func() (interface{}, error) { cfg := MinioTestConfig{} - cfg.tempdir, cfg.removeTempdir = TempDir(t) + cfg.tempdir, cfg.removeTempdir = rtest.TempDir(t) key, secret := newRandomCredentials(t) cfg.stopServer = runMinio(ctx, t, cfg.tempdir, key, secret) @@ -182,7 +182,7 @@ func newMinioTestSuite(ctx context.Context, t testing.TB) *test.Suite { func TestBackendMinio(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/s3.TestBackendMinio") + rtest.SkipDisallowed(t, "restic/backend/s3.TestBackendMinio") } }() @@ -280,7 +280,7 @@ func newS3TestSuite(t testing.TB) *test.Suite { func TestBackendS3(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/s3.TestBackendS3") + rtest.SkipDisallowed(t, "restic/backend/s3.TestBackendS3") } }() diff --git a/internal/backend/sftp/layout_test.go b/internal/backend/sftp/layout_test.go index 9a5878e0d..0a9e9eae9 100644 --- a/internal/backend/sftp/layout_test.go +++ b/internal/backend/sftp/layout_test.go @@ -8,7 +8,7 @@ import ( "github.com/restic/restic/internal/backend/sftp" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestLayout(t *testing.T) { @@ -16,7 +16,7 @@ func TestLayout(t *testing.T) { t.Skip("sftp server binary not available") } - path, cleanup := TempDir(t) + path, cleanup := rtest.TempDir(t) defer cleanup() var tests = []struct { @@ -39,7 +39,7 @@ func TestLayout(t *testing.T) { for _, test := range tests { t.Run(test.filename, func(t *testing.T) { - SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename)) + rtest.SetupTarTestFixture(t, path, filepath.Join("..", "testdata", test.filename)) repo := filepath.Join(path, "repo") be, err := sftp.Open(sftp.Config{ @@ -82,7 +82,7 @@ func TestLayout(t *testing.T) { t.Errorf("Close() returned error %v", err) } - RemoveAll(t, filepath.Join(path, "repo")) + rtest.RemoveAll(t, filepath.Join(path, "repo")) }) } } diff --git a/internal/backend/sftp/sftp_test.go b/internal/backend/sftp/sftp_test.go index 56d9f9172..513d6e7d3 100644 --- a/internal/backend/sftp/sftp_test.go +++ b/internal/backend/sftp/sftp_test.go @@ -12,12 +12,11 @@ import ( "github.com/restic/restic/internal/backend/test" "github.com/restic/restic/internal/errors" "github.com/restic/restic/internal/restic" - - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func findSFTPServerBinary() string { - for _, dir := range strings.Split(TestSFTPPath, ":") { + for _, dir := range strings.Split(rtest.TestSFTPPath, ":") { testpath := filepath.Join(dir, "sftp-server") _, err := os.Stat(testpath) if !os.IsNotExist(errors.Cause(err)) { @@ -34,7 +33,7 @@ func newTestSuite(t testing.TB) *test.Suite { return &test.Suite{ // NewConfig returns a config for a new temporary backend that will be used in tests. NewConfig: func() (interface{}, error) { - dir, err := ioutil.TempDir(TestTempDir, "restic-test-sftp-") + dir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-sftp-") if err != nil { t.Fatal(err) } @@ -63,11 +62,11 @@ func newTestSuite(t testing.TB) *test.Suite { // CleanupFn removes data created during the tests. Cleanup: func(config interface{}) error { cfg := config.(sftp.Config) - if !TestCleanupTempDirs { + if !rtest.TestCleanupTempDirs { t.Logf("leaving test backend dir at %v", cfg.Path) } - RemoveAll(t, cfg.Path) + rtest.RemoveAll(t, cfg.Path) return nil }, } @@ -76,7 +75,7 @@ func newTestSuite(t testing.TB) *test.Suite { func TestBackendSFTP(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/sftp.TestBackendSFTP") + rtest.SkipDisallowed(t, "restic/backend/sftp.TestBackendSFTP") } }() diff --git a/internal/backend/swift/swift_test.go b/internal/backend/swift/swift_test.go index eea6302b2..ce8693c33 100644 --- a/internal/backend/swift/swift_test.go +++ b/internal/backend/swift/swift_test.go @@ -7,12 +7,11 @@ import ( "testing" "time" - "github.com/restic/restic/internal/errors" - "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" - "github.com/restic/restic/internal/backend/swift" "github.com/restic/restic/internal/backend/test" + "github.com/restic/restic/internal/errors" + "github.com/restic/restic/internal/restic" + rtest "github.com/restic/restic/internal/test" ) func newSwiftTestSuite(t testing.TB) *test.Suite { @@ -100,7 +99,7 @@ func newSwiftTestSuite(t testing.TB) *test.Suite { func TestBackendSwift(t *testing.T) { defer func() { if t.Skipped() { - SkipDisallowed(t, "restic/backend/swift.TestBackendSwift") + rtest.SkipDisallowed(t, "restic/backend/swift.TestBackendSwift") } }() diff --git a/internal/backend/utils_test.go b/internal/backend/utils_test.go index 09415f5e9..b281588fc 100644 --- a/internal/backend/utils_test.go +++ b/internal/backend/utils_test.go @@ -9,7 +9,7 @@ import ( "github.com/restic/restic/internal/backend" "github.com/restic/restic/internal/backend/mem" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) const KiB = 1 << 10 @@ -19,14 +19,14 @@ func TestLoadAll(t *testing.T) { b := mem.New() for i := 0; i < 20; i++ { - data := Random(23+i, rand.Intn(MiB)+500*KiB) + data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB) id := restic.Hash(data) err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data)) - OK(t, err) + rtest.OK(t, err) buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()}) - OK(t, err) + rtest.OK(t, err) if len(buf) != len(data) { t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf)) @@ -44,14 +44,14 @@ func TestLoadSmallBuffer(t *testing.T) { b := mem.New() for i := 0; i < 20; i++ { - data := Random(23+i, rand.Intn(MiB)+500*KiB) + data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB) id := restic.Hash(data) err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data)) - OK(t, err) + rtest.OK(t, err) buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()}) - OK(t, err) + rtest.OK(t, err) if len(buf) != len(data) { t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf)) @@ -69,14 +69,14 @@ func TestLoadLargeBuffer(t *testing.T) { b := mem.New() for i := 0; i < 20; i++ { - data := Random(23+i, rand.Intn(MiB)+500*KiB) + data := rtest.Random(23+i, rand.Intn(MiB)+500*KiB) id := restic.Hash(data) err := b.Save(context.TODO(), restic.Handle{Name: id.String(), Type: restic.DataFile}, bytes.NewReader(data)) - OK(t, err) + rtest.OK(t, err) buf, err := backend.LoadAll(context.TODO(), b, restic.Handle{Type: restic.DataFile, Name: id.String()}) - OK(t, err) + rtest.OK(t, err) if len(buf) != len(data) { t.Errorf("length of returned buffer does not match, want %d, got %d", len(data), len(buf)) diff --git a/internal/crypto/crypto_test.go b/internal/crypto/crypto_test.go index b9d3d4bca..f1a7b7994 100644 --- a/internal/crypto/crypto_test.go +++ b/internal/crypto/crypto_test.go @@ -7,7 +7,7 @@ import ( "testing" "github.com/restic/restic/internal/crypto" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" "github.com/restic/chunker" ) @@ -23,24 +23,24 @@ func TestEncryptDecrypt(t *testing.T) { } for _, size := range tests { - data := Random(42, size) + data := rtest.Random(42, size) buf := make([]byte, size+crypto.Extension) ciphertext, err := k.Encrypt(buf, data) - OK(t, err) - Assert(t, len(ciphertext) == len(data)+crypto.Extension, + rtest.OK(t, err) + rtest.Assert(t, len(ciphertext) == len(data)+crypto.Extension, "ciphertext length does not match: want %d, got %d", len(data)+crypto.Extension, len(ciphertext)) plaintext := make([]byte, len(ciphertext)) n, err := k.Decrypt(plaintext, ciphertext) - OK(t, err) + rtest.OK(t, err) plaintext = plaintext[:n] - Assert(t, len(plaintext) == len(data), + rtest.Assert(t, len(plaintext) == len(data), "plaintext length does not match: want %d, got %d", len(data), len(plaintext)) - Equals(t, plaintext, data) + rtest.Equals(t, plaintext, data) } } @@ -50,21 +50,21 @@ func TestSmallBuffer(t *testing.T) { size := 600 data := make([]byte, size) _, err := io.ReadFull(rand.Reader, data) - OK(t, err) + rtest.OK(t, err) ciphertext := make([]byte, size/2) ciphertext, err = k.Encrypt(ciphertext, data) // this must extend the slice - Assert(t, cap(ciphertext) > size/2, + rtest.Assert(t, cap(ciphertext) > size/2, "expected extended slice, but capacity is only %d bytes", cap(ciphertext)) // check for the correct plaintext plaintext := make([]byte, len(ciphertext)) n, err := k.Decrypt(plaintext, ciphertext) - OK(t, err) + rtest.OK(t, err) plaintext = plaintext[:n] - Assert(t, bytes.Equal(plaintext, data), + rtest.Assert(t, bytes.Equal(plaintext, data), "wrong plaintext returned") } @@ -74,18 +74,18 @@ func TestSameBuffer(t *testing.T) { size := 600 data := make([]byte, size) _, err := io.ReadFull(rand.Reader, data) - OK(t, err) + rtest.OK(t, err) ciphertext := make([]byte, 0, size+crypto.Extension) ciphertext, err = k.Encrypt(ciphertext, data) - OK(t, err) + rtest.OK(t, err) // use the same buffer for decryption n, err := k.Decrypt(ciphertext, ciphertext) - OK(t, err) + rtest.OK(t, err) ciphertext = ciphertext[:n] - Assert(t, bytes.Equal(ciphertext, data), + rtest.Assert(t, bytes.Equal(ciphertext, data), "wrong plaintext returned") } @@ -95,20 +95,20 @@ func TestCornerCases(t *testing.T) { // nil plaintext should encrypt to the empty string // nil ciphertext should allocate a new slice for the ciphertext c, err := k.Encrypt(nil, nil) - OK(t, err) + rtest.OK(t, err) - Assert(t, len(c) == crypto.Extension, + rtest.Assert(t, len(c) == crypto.Extension, "wrong length returned for ciphertext, expected 0, got %d", len(c)) // this should decrypt to nil n, err := k.Decrypt(nil, c) - OK(t, err) - Equals(t, 0, n) + rtest.OK(t, err) + rtest.Equals(t, 0, n) // test encryption for same slice, this should return an error _, err = k.Encrypt(c, c) - Equals(t, crypto.ErrInvalidCiphertext, err) + rtest.Equals(t, crypto.ErrInvalidCiphertext, err) } func TestLargeEncrypt(t *testing.T) { @@ -121,15 +121,15 @@ func TestLargeEncrypt(t *testing.T) { for _, size := range []int{chunker.MaxSize, chunker.MaxSize + 1, chunker.MaxSize + 1<<20} { data := make([]byte, size) _, err := io.ReadFull(rand.Reader, data) - OK(t, err) + rtest.OK(t, err) ciphertext, err := k.Encrypt(make([]byte, size+crypto.Extension), data) - OK(t, err) + rtest.OK(t, err) plaintext, err := k.Decrypt([]byte{}, ciphertext) - OK(t, err) + rtest.OK(t, err) - Equals(t, plaintext, data) + rtest.Equals(t, plaintext, data) } } @@ -145,7 +145,7 @@ func BenchmarkEncrypt(b *testing.B) { for i := 0; i < b.N; i++ { _, err := k.Encrypt(buf, data) - OK(b, err) + rtest.OK(b, err) } } @@ -159,13 +159,13 @@ func BenchmarkDecrypt(b *testing.B) { ciphertext := make([]byte, size+crypto.Extension) ciphertext, err := k.Encrypt(ciphertext, data) - OK(b, err) + rtest.OK(b, err) b.ResetTimer() b.SetBytes(int64(size)) for i := 0; i < b.N; i++ { _, err = k.Decrypt(plaintext, ciphertext) - OK(b, err) + rtest.OK(b, err) } } diff --git a/internal/fuse/file_test.go b/internal/fuse/file_test.go index d8aae46de..121c218f5 100644 --- a/internal/fuse/file_test.go +++ b/internal/fuse/file_test.go @@ -17,7 +17,7 @@ import ( "bazil.org/fuse" "bazil.org/fuse/fs" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func testRead(t testing.TB, f *file, offset, length int, data []byte) { @@ -31,7 +31,7 @@ func testRead(t testing.TB, f *file, offset, length int, data []byte) { resp := &fuse.ReadResponse{ Data: data, } - OK(t, f.Read(ctx, req, resp)) + rtest.OK(t, f.Read(ctx, req, resp)) } func firstSnapshotID(t testing.TB, repo restic.Repository) (first restic.ID) { @@ -46,13 +46,13 @@ func firstSnapshotID(t testing.TB, repo restic.Repository) (first restic.ID) { func loadFirstSnapshot(t testing.TB, repo restic.Repository) *restic.Snapshot { id := firstSnapshotID(t, repo) sn, err := restic.LoadSnapshot(context.TODO(), repo, id) - OK(t, err) + rtest.OK(t, err) return sn } func loadTree(t testing.TB, repo restic.Repository, id restic.ID) *restic.Tree { tree, err := repo.LoadTree(context.TODO(), id) - OK(t, err) + rtest.OK(t, err) return tree } @@ -64,7 +64,7 @@ func TestFuseFile(t *testing.T) { defer cancel() timestamp, err := time.Parse(time.RFC3339, "2017-01-24T10:42:56+01:00") - OK(t, err) + rtest.OK(t, err) restic.TestCreateSnapshot(t, repo, timestamp, 2, 0.1) sn := loadFirstSnapshot(t, repo) @@ -82,12 +82,12 @@ func TestFuseFile(t *testing.T) { ) for _, id := range content { size, err := repo.LookupBlobSize(id, restic.DataBlob) - OK(t, err) + rtest.OK(t, err) filesize += uint64(size) buf := restic.NewBlobBuffer(int(size)) n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf) - OK(t, err) + rtest.OK(t, err) if uint(n) != size { t.Fatalf("not enough bytes read for id %v: want %v, got %v", id.Str(), size, n) @@ -118,15 +118,15 @@ func TestFuseFile(t *testing.T) { inode := fs.GenerateDynamicInode(1, "foo") f, err := newFile(context.TODO(), root, inode, node) - OK(t, err) + rtest.OK(t, err) attr := fuse.Attr{} - OK(t, f.Attr(ctx, &attr)) + rtest.OK(t, f.Attr(ctx, &attr)) - Equals(t, inode, attr.Inode) - Equals(t, node.Mode, attr.Mode) - Equals(t, node.Size, attr.Size) - Equals(t, (node.Size/uint64(attr.BlockSize))+1, attr.Blocks) + rtest.Equals(t, inode, attr.Inode) + rtest.Equals(t, node.Mode, attr.Mode) + rtest.Equals(t, node.Size, attr.Size) + rtest.Equals(t, (node.Size/uint64(attr.BlockSize))+1, attr.Blocks) for i := 0; i < 200; i++ { offset := rand.Intn(int(filesize)) @@ -142,5 +142,5 @@ func TestFuseFile(t *testing.T) { } } - OK(t, f.Release(ctx, nil)) + rtest.OK(t, f.Release(ctx, nil)) } diff --git a/internal/pack/pack_test.go b/internal/pack/pack_test.go index fc1e7ae1a..a61b28a2b 100644 --- a/internal/pack/pack_test.go +++ b/internal/pack/pack_test.go @@ -14,7 +14,7 @@ import ( "github.com/restic/restic/internal/crypto" "github.com/restic/restic/internal/pack" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) var testLens = []int{23, 31650, 25860, 10928, 13769, 19862, 5211, 127, 13690, 30231} @@ -30,7 +30,7 @@ func newPack(t testing.TB, k *crypto.Key, lengths []int) ([]Buf, []byte, uint) { for _, l := range lengths { b := make([]byte, l) _, err := io.ReadFull(rand.Reader, b) - OK(t, err) + rtest.OK(t, err) h := sha256.Sum256(b) bufs = append(bufs, Buf{data: b, id: h}) } @@ -42,7 +42,7 @@ func newPack(t testing.TB, k *crypto.Key, lengths []int) ([]Buf, []byte, uint) { } _, err := p.Finalize() - OK(t, err) + rtest.OK(t, err) packData := p.Writer().(*bytes.Buffer).Bytes() return bufs, packData, p.Size() @@ -60,27 +60,27 @@ func verifyBlobs(t testing.TB, bufs []Buf, k *crypto.Key, rd io.ReaderAt, packSi written += restic.CiphertextLength(headerSize) // check length - Equals(t, uint(written), packSize) + rtest.Equals(t, uint(written), packSize) // read and parse it again entries, err := pack.List(k, rd, int64(packSize)) - OK(t, err) - Equals(t, len(entries), len(bufs)) + rtest.OK(t, err) + rtest.Equals(t, len(entries), len(bufs)) var buf []byte for i, b := range bufs { e := entries[i] - Equals(t, b.id, e.ID) + rtest.Equals(t, b.id, e.ID) if len(buf) < int(e.Length) { buf = make([]byte, int(e.Length)) } buf = buf[:int(e.Length)] n, err := rd.ReadAt(buf, int64(e.Offset)) - OK(t, err) + rtest.OK(t, err) buf = buf[:n] - Assert(t, bytes.Equal(b.data, buf), + rtest.Assert(t, bytes.Equal(b.data, buf), "data for blob %v doesn't match", i) } } @@ -90,7 +90,7 @@ func TestCreatePack(t *testing.T) { k := crypto.NewRandomKey() bufs, packData, packSize := newPack(t, k, testLens) - Equals(t, uint(len(packData)), packSize) + rtest.Equals(t, uint(len(packData)), packSize) verifyBlobs(t, bufs, k, bytes.NewReader(packData), packSize) } @@ -106,14 +106,14 @@ func TestBlobTypeJSON(t *testing.T) { for _, test := range blobTypeJSON { // test serialize buf, err := json.Marshal(test.t) - OK(t, err) - Equals(t, test.res, string(buf)) + rtest.OK(t, err) + rtest.Equals(t, test.res, string(buf)) // test unserialize var v restic.BlobType err = json.Unmarshal([]byte(test.res), &v) - OK(t, err) - Equals(t, test.t, v) + rtest.OK(t, err) + rtest.Equals(t, test.t, v) } } @@ -127,7 +127,7 @@ func TestUnpackReadSeeker(t *testing.T) { id := restic.Hash(packData) handle := restic.Handle{Type: restic.DataFile, Name: id.String()} - OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData))) + rtest.OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData))) verifyBlobs(t, bufs, k, restic.ReaderAt(b, handle), packSize) } @@ -140,6 +140,6 @@ func TestShortPack(t *testing.T) { id := restic.Hash(packData) handle := restic.Handle{Type: restic.DataFile, Name: id.String()} - OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData))) + rtest.OK(t, b.Save(context.TODO(), handle, bytes.NewReader(packData))) verifyBlobs(t, bufs, k, restic.ReaderAt(b, handle), packSize) } diff --git a/internal/pipe/pipe_test.go b/internal/pipe/pipe_test.go index 377511b6c..1612987e7 100644 --- a/internal/pipe/pipe_test.go +++ b/internal/pipe/pipe_test.go @@ -12,7 +12,7 @@ import ( "github.com/restic/restic/internal/debug" "github.com/restic/restic/internal/pipe" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) type stats struct { @@ -27,7 +27,7 @@ func statPath(path string) (stats, error) { var s stats // count files and directories with filepath.Walk() - err := filepath.Walk(TestWalkerPath, func(p string, fi os.FileInfo, err error) error { + err := filepath.Walk(rtest.TestWalkerPath, func(p string, fi os.FileInfo, err error) error { if fi == nil { return err } @@ -47,20 +47,20 @@ func statPath(path string) (stats, error) { const maxWorkers = 100 func TestPipelineWalkerWithSplit(t *testing.T) { - if TestWalkerPath == "" { + if rtest.TestWalkerPath == "" { t.Skipf("walkerpath not set, skipping TestPipelineWalker") } var err error - if !filepath.IsAbs(TestWalkerPath) { - TestWalkerPath, err = filepath.Abs(TestWalkerPath) - OK(t, err) + if !filepath.IsAbs(rtest.TestWalkerPath) { + rtest.TestWalkerPath, err = filepath.Abs(rtest.TestWalkerPath) + rtest.OK(t, err) } - before, err := statPath(TestWalkerPath) - OK(t, err) + before, err := statPath(rtest.TestWalkerPath) + rtest.OK(t, err) - t.Logf("walking path %s with %d dirs, %d files", TestWalkerPath, + t.Logf("walking path %s with %d dirs, %d files", rtest.TestWalkerPath, before.dirs, before.files) // account for top level dir @@ -128,7 +128,7 @@ func TestPipelineWalkerWithSplit(t *testing.T) { }() resCh := make(chan pipe.Result, 1) - pipe.Walk(context.TODO(), []string{TestWalkerPath}, acceptAll, jobs, resCh) + pipe.Walk(context.TODO(), []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh) // wait for all workers to terminate wg.Wait() @@ -136,14 +136,14 @@ func TestPipelineWalkerWithSplit(t *testing.T) { // wait for top-level blob <-resCh - t.Logf("walked path %s with %d dirs, %d files", TestWalkerPath, + t.Logf("walked path %s with %d dirs, %d files", rtest.TestWalkerPath, after.dirs, after.files) - Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) + rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) } func TestPipelineWalker(t *testing.T) { - if TestWalkerPath == "" { + if rtest.TestWalkerPath == "" { t.Skipf("walkerpath not set, skipping TestPipelineWalker") } @@ -151,15 +151,15 @@ func TestPipelineWalker(t *testing.T) { defer cancel() var err error - if !filepath.IsAbs(TestWalkerPath) { - TestWalkerPath, err = filepath.Abs(TestWalkerPath) - OK(t, err) + if !filepath.IsAbs(rtest.TestWalkerPath) { + rtest.TestWalkerPath, err = filepath.Abs(rtest.TestWalkerPath) + rtest.OK(t, err) } - before, err := statPath(TestWalkerPath) - OK(t, err) + before, err := statPath(rtest.TestWalkerPath) + rtest.OK(t, err) - t.Logf("walking path %s with %d dirs, %d files", TestWalkerPath, + t.Logf("walking path %s with %d dirs, %d files", rtest.TestWalkerPath, before.dirs, before.files) // account for top level dir @@ -177,7 +177,7 @@ func TestPipelineWalker(t *testing.T) { // channel is closed return } - Assert(t, job != nil, "job is nil") + rtest.Assert(t, job != nil, "job is nil") switch j := job.(type) { case pipe.Dir: @@ -215,7 +215,7 @@ func TestPipelineWalker(t *testing.T) { } resCh := make(chan pipe.Result, 1) - pipe.Walk(ctx, []string{TestWalkerPath}, acceptAll, jobs, resCh) + pipe.Walk(ctx, []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh) // wait for all workers to terminate wg.Wait() @@ -223,10 +223,10 @@ func TestPipelineWalker(t *testing.T) { // wait for top-level blob <-resCh - t.Logf("walked path %s with %d dirs, %d files", TestWalkerPath, + t.Logf("walked path %s with %d dirs, %d files", rtest.TestWalkerPath, after.dirs, after.files) - Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) + rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) } func createFile(filename, data string) error { @@ -247,7 +247,7 @@ func createFile(filename, data string) error { func TestPipeWalkerError(t *testing.T) { dir, err := ioutil.TempDir("", "restic-test-") - OK(t, err) + rtest.OK(t, err) base := filepath.Base(dir) @@ -264,13 +264,13 @@ func TestPipeWalkerError(t *testing.T) { {[]string{}, false}, } - OK(t, os.Mkdir(filepath.Join(dir, "a"), 0755)) - OK(t, os.Mkdir(filepath.Join(dir, "b"), 0755)) - OK(t, os.Mkdir(filepath.Join(dir, "c"), 0755)) + rtest.OK(t, os.Mkdir(filepath.Join(dir, "a"), 0755)) + rtest.OK(t, os.Mkdir(filepath.Join(dir, "b"), 0755)) + rtest.OK(t, os.Mkdir(filepath.Join(dir, "c"), 0755)) - OK(t, createFile(filepath.Join(dir, "a", "file_a"), "file a")) - OK(t, createFile(filepath.Join(dir, "b", "file_b"), "file b")) - OK(t, createFile(filepath.Join(dir, "c", "file_c"), "file c")) + rtest.OK(t, createFile(filepath.Join(dir, "a", "file_a"), "file a")) + rtest.OK(t, createFile(filepath.Join(dir, "b", "file_b"), "file b")) + rtest.OK(t, createFile(filepath.Join(dir, "c", "file_c"), "file c")) ranHook := false testdir := filepath.Join(dir, "b") @@ -286,7 +286,7 @@ func TestPipeWalkerError(t *testing.T) { t.Logf("in hook, removing test file %v", testdir) ranHook = true - OK(t, os.RemoveAll(testdir)) + rtest.OK(t, os.RemoveAll(testdir)) }) ctx, cancel := context.WithCancel(context.TODO()) @@ -327,12 +327,12 @@ func TestPipeWalkerError(t *testing.T) { cancel() - Assert(t, ranHook, "hook did not run") - OK(t, os.RemoveAll(dir)) + rtest.Assert(t, ranHook, "hook did not run") + rtest.OK(t, os.RemoveAll(dir)) } func BenchmarkPipelineWalker(b *testing.B) { - if TestWalkerPath == "" { + if rtest.TestWalkerPath == "" { b.Skipf("walkerpath not set, skipping BenchPipelineWalker") } @@ -418,7 +418,7 @@ func BenchmarkPipelineWalker(b *testing.B) { }() resCh := make(chan pipe.Result, 1) - pipe.Walk(ctx, []string{TestWalkerPath}, acceptAll, jobs, resCh) + pipe.Walk(ctx, []string{rtest.TestWalkerPath}, acceptAll, jobs, resCh) // wait for all workers to terminate wg.Wait() @@ -431,18 +431,18 @@ func BenchmarkPipelineWalker(b *testing.B) { } func TestPipelineWalkerMultiple(t *testing.T) { - if TestWalkerPath == "" { + if rtest.TestWalkerPath == "" { t.Skipf("walkerpath not set, skipping TestPipelineWalker") } ctx, cancel := context.WithCancel(context.TODO()) defer cancel() - paths, err := filepath.Glob(filepath.Join(TestWalkerPath, "*")) - OK(t, err) + paths, err := filepath.Glob(filepath.Join(rtest.TestWalkerPath, "*")) + rtest.OK(t, err) - before, err := statPath(TestWalkerPath) - OK(t, err) + before, err := statPath(rtest.TestWalkerPath) + rtest.OK(t, err) t.Logf("walking paths %v with %d dirs, %d files", paths, before.dirs, before.files) @@ -459,7 +459,7 @@ func TestPipelineWalkerMultiple(t *testing.T) { // channel is closed return } - Assert(t, job != nil, "job is nil") + rtest.Assert(t, job != nil, "job is nil") switch j := job.(type) { case pipe.Dir: @@ -507,7 +507,7 @@ func TestPipelineWalkerMultiple(t *testing.T) { t.Logf("walked %d paths with %d dirs, %d files", len(paths), after.dirs, after.files) - Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) + rtest.Assert(t, before == after, "stats do not match, expected %v, got %v", before, after) } func dirsInPath(path string) int { @@ -530,7 +530,7 @@ func TestPipeWalkerRoot(t *testing.T) { } cwd, err := os.Getwd() - OK(t, err) + rtest.OK(t, err) testPaths := []string{ string(filepath.Separator), @@ -546,11 +546,11 @@ func TestPipeWalkerRoot(t *testing.T) { func testPipeWalkerRootWithPath(path string, t *testing.T) { pattern := filepath.Join(path, "*") rootPaths, err := filepath.Glob(pattern) - OK(t, err) + rtest.OK(t, err) for i, p := range rootPaths { rootPaths[i], err = filepath.Rel(path, p) - OK(t, err) + rtest.OK(t, err) } t.Logf("paths in %v (pattern %q) expanded to %v items", path, pattern, len(rootPaths)) @@ -571,7 +571,7 @@ func testPipeWalkerRootWithPath(path string, t *testing.T) { filter := func(p string, fi os.FileInfo) bool { p, err := filepath.Rel(path, p) - OK(t, err) + rtest.OK(t, err) return dirsInPath(p) <= 1 } diff --git a/internal/repository/index_test.go b/internal/repository/index_test.go index 4cd315c66..f0ca4e19b 100644 --- a/internal/repository/index_test.go +++ b/internal/repository/index_test.go @@ -6,7 +6,7 @@ import ( "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestIndexSerialize(t *testing.T) { @@ -52,43 +52,43 @@ func TestIndexSerialize(t *testing.T) { wr := bytes.NewBuffer(nil) err := idx.Encode(wr) - OK(t, err) + rtest.OK(t, err) idx2, err := repository.DecodeIndex(wr.Bytes()) - OK(t, err) - Assert(t, idx2 != nil, + rtest.OK(t, err) + rtest.Assert(t, idx2 != nil, "nil returned for decoded index") wr2 := bytes.NewBuffer(nil) err = idx2.Encode(wr2) - OK(t, err) + rtest.OK(t, err) for _, testBlob := range tests { list, err := idx.Lookup(testBlob.id, testBlob.tpe) - OK(t, err) + rtest.OK(t, err) if len(list) != 1 { t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list) } result := list[0] - Equals(t, testBlob.pack, result.PackID) - Equals(t, testBlob.tpe, result.Type) - Equals(t, testBlob.offset, result.Offset) - Equals(t, testBlob.length, result.Length) + rtest.Equals(t, testBlob.pack, result.PackID) + rtest.Equals(t, testBlob.tpe, result.Type) + rtest.Equals(t, testBlob.offset, result.Offset) + rtest.Equals(t, testBlob.length, result.Length) list2, err := idx2.Lookup(testBlob.id, testBlob.tpe) - OK(t, err) + rtest.OK(t, err) if len(list2) != 1 { t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list2), list2) } result2 := list2[0] - Equals(t, testBlob.pack, result2.PackID) - Equals(t, testBlob.tpe, result2.Type) - Equals(t, testBlob.offset, result2.Offset) - Equals(t, testBlob.length, result2.Length) + rtest.Equals(t, testBlob.pack, result2.PackID) + rtest.Equals(t, testBlob.tpe, result2.Type) + rtest.Equals(t, testBlob.offset, result2.Offset) + rtest.Equals(t, testBlob.length, result2.Length) } // add more blobs to idx @@ -125,28 +125,28 @@ func TestIndexSerialize(t *testing.T) { // serialize idx, unserialize to idx3 wr3 := bytes.NewBuffer(nil) err = idx.Finalize(wr3) - OK(t, err) + rtest.OK(t, err) - Assert(t, idx.Final(), + rtest.Assert(t, idx.Final(), "index not final after encoding") id := restic.NewRandomID() - OK(t, idx.SetID(id)) + rtest.OK(t, idx.SetID(id)) id2, err := idx.ID() - Assert(t, id2.Equal(id), + rtest.Assert(t, id2.Equal(id), "wrong ID returned: want %v, got %v", id, id2) idx3, err := repository.DecodeIndex(wr3.Bytes()) - OK(t, err) - Assert(t, idx3 != nil, + rtest.OK(t, err) + rtest.Assert(t, idx3 != nil, "nil returned for decoded index") - Assert(t, idx3.Final(), + rtest.Assert(t, idx3.Final(), "decoded index is not final") // all new blobs must be in the index for _, testBlob := range newtests { list, err := idx3.Lookup(testBlob.id, testBlob.tpe) - OK(t, err) + rtest.OK(t, err) if len(list) != 1 { t.Errorf("expected one result for blob %v, got %v: %v", testBlob.id.Str(), len(list), list) @@ -154,10 +154,10 @@ func TestIndexSerialize(t *testing.T) { blob := list[0] - Equals(t, testBlob.pack, blob.PackID) - Equals(t, testBlob.tpe, blob.Type) - Equals(t, testBlob.offset, blob.Offset) - Equals(t, testBlob.length, blob.Length) + rtest.Equals(t, testBlob.pack, blob.PackID) + rtest.Equals(t, testBlob.tpe, blob.Type) + rtest.Equals(t, testBlob.offset, blob.Offset) + rtest.Equals(t, testBlob.length, blob.Length) } } @@ -190,7 +190,7 @@ func TestIndexSize(t *testing.T) { wr := bytes.NewBuffer(nil) err := idx.Encode(wr) - OK(t, err) + rtest.OK(t, err) t.Logf("Index file size for %d blobs in %d packs is %d", blobs*packs, packs, wr.Len()) } @@ -289,11 +289,11 @@ func TestIndexUnserialize(t *testing.T) { oldIdx := restic.IDs{restic.TestParseID("ed54ae36197f4745ebc4b54d10e0f623eaaaedd03013eb7ae90df881b7781452")} idx, err := repository.DecodeIndex(docExample) - OK(t, err) + rtest.OK(t, err) for _, test := range exampleTests { list, err := idx.Lookup(test.id, test.tpe) - OK(t, err) + rtest.OK(t, err) if len(list) != 1 { t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list) @@ -302,13 +302,13 @@ func TestIndexUnserialize(t *testing.T) { t.Logf("looking for blob %v/%v, got %v", test.tpe, test.id.Str(), blob) - Equals(t, test.packID, blob.PackID) - Equals(t, test.tpe, blob.Type) - Equals(t, test.offset, blob.Offset) - Equals(t, test.length, blob.Length) + rtest.Equals(t, test.packID, blob.PackID) + rtest.Equals(t, test.tpe, blob.Type) + rtest.Equals(t, test.offset, blob.Offset) + rtest.Equals(t, test.length, blob.Length) } - Equals(t, oldIdx, idx.Supersedes()) + rtest.Equals(t, oldIdx, idx.Supersedes()) blobs := idx.ListPack(exampleLookupTest.packID) if len(blobs) != len(exampleLookupTest.blobs) { @@ -331,30 +331,30 @@ func BenchmarkDecodeIndex(b *testing.B) { for i := 0; i < b.N; i++ { _, err := repository.DecodeIndex(docExample) - OK(b, err) + rtest.OK(b, err) } } func TestIndexUnserializeOld(t *testing.T) { idx, err := repository.DecodeOldIndex(docOldExample) - OK(t, err) + rtest.OK(t, err) for _, test := range exampleTests { list, err := idx.Lookup(test.id, test.tpe) - OK(t, err) + rtest.OK(t, err) if len(list) != 1 { t.Errorf("expected one result for blob %v, got %v: %v", test.id.Str(), len(list), list) } blob := list[0] - Equals(t, test.packID, blob.PackID) - Equals(t, test.tpe, blob.Type) - Equals(t, test.offset, blob.Offset) - Equals(t, test.length, blob.Length) + rtest.Equals(t, test.packID, blob.PackID) + rtest.Equals(t, test.tpe, blob.Type) + rtest.Equals(t, test.offset, blob.Offset) + rtest.Equals(t, test.length, blob.Length) } - Equals(t, 0, len(idx.Supersedes())) + rtest.Equals(t, 0, len(idx.Supersedes())) } func TestIndexPacks(t *testing.T) { @@ -377,5 +377,5 @@ func TestIndexPacks(t *testing.T) { } idxPacks := idx.Packs() - Assert(t, packs.Equals(idxPacks), "packs in index do not match packs added to index") + rtest.Assert(t, packs.Equals(idxPacks), "packs in index do not match packs added to index") } diff --git a/internal/repository/parallel_test.go b/internal/repository/parallel_test.go index a7ebdb5e0..9fa3687bb 100644 --- a/internal/repository/parallel_test.go +++ b/internal/repository/parallel_test.go @@ -10,7 +10,7 @@ import ( "github.com/restic/restic/internal/restic" "github.com/restic/restic/internal/repository" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) type testIDs []string @@ -102,7 +102,7 @@ func TestFilesInParallel(t *testing.T) { for n := uint(1); n < 5; n++ { err := repository.FilesInParallel(context.TODO(), lister, restic.DataFile, n*100, f) - OK(t, err) + rtest.OK(t, err) } } @@ -122,6 +122,6 @@ func TestFilesInParallelWithError(t *testing.T) { for n := uint(1); n < 5; n++ { err := repository.FilesInParallel(context.TODO(), lister, restic.DataFile, n*100, f) - Equals(t, errTest, err) + rtest.Equals(t, errTest, err) } } diff --git a/internal/repository/repository_test.go b/internal/repository/repository_test.go index 7211058b0..d3b9dec93 100644 --- a/internal/repository/repository_test.go +++ b/internal/repository/repository_test.go @@ -13,7 +13,7 @@ import ( "github.com/restic/restic/internal/archiver" "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) var testSizes = []int{5, 23, 2<<18 + 23, 1 << 20} @@ -27,30 +27,30 @@ func TestSave(t *testing.T) { for _, size := range testSizes { data := make([]byte, size) _, err := io.ReadFull(rnd, data) - OK(t, err) + rtest.OK(t, err) id := restic.Hash(data) // save sid, err := repo.SaveBlob(context.TODO(), restic.DataBlob, data, restic.ID{}) - OK(t, err) + rtest.OK(t, err) - Equals(t, id, sid) + rtest.Equals(t, id, sid) - OK(t, repo.Flush()) - // OK(t, repo.SaveIndex()) + rtest.OK(t, repo.Flush()) + // rtest.OK(t, repo.SaveIndex()) // read back buf := restic.NewBlobBuffer(size) n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf) - OK(t, err) - Equals(t, len(buf), n) + rtest.OK(t, err) + rtest.Equals(t, len(buf), n) - Assert(t, len(buf) == len(data), + rtest.Assert(t, len(buf) == len(data), "number of bytes read back does not match: expected %d, got %d", len(data), len(buf)) - Assert(t, bytes.Equal(buf, data), + rtest.Assert(t, bytes.Equal(buf, data), "data does not match: expected %02x, got %02x", data, buf) } @@ -63,28 +63,28 @@ func TestSaveFrom(t *testing.T) { for _, size := range testSizes { data := make([]byte, size) _, err := io.ReadFull(rnd, data) - OK(t, err) + rtest.OK(t, err) id := restic.Hash(data) // save id2, err := repo.SaveBlob(context.TODO(), restic.DataBlob, data, id) - OK(t, err) - Equals(t, id, id2) + rtest.OK(t, err) + rtest.Equals(t, id, id2) - OK(t, repo.Flush()) + rtest.OK(t, repo.Flush()) // read back buf := restic.NewBlobBuffer(size) n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf) - OK(t, err) - Equals(t, len(buf), n) + rtest.OK(t, err) + rtest.Equals(t, len(buf), n) - Assert(t, len(buf) == len(data), + rtest.Assert(t, len(buf) == len(data), "number of bytes read back does not match: expected %d, got %d", len(data), len(buf)) - Assert(t, bytes.Equal(buf, data), + rtest.Assert(t, bytes.Equal(buf, data), "data does not match: expected %02x, got %02x", data, buf) } @@ -98,7 +98,7 @@ func BenchmarkSaveAndEncrypt(t *testing.B) { data := make([]byte, size) _, err := io.ReadFull(rnd, data) - OK(t, err) + rtest.OK(t, err) id := restic.ID(sha256.Sum256(data)) @@ -108,7 +108,7 @@ func BenchmarkSaveAndEncrypt(t *testing.B) { for i := 0; i < t.N; i++ { // save _, err = repo.SaveBlob(context.TODO(), restic.DataBlob, data, id) - OK(t, err) + rtest.OK(t, err) } } @@ -116,35 +116,35 @@ func TestLoadTree(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { t.Skip("benchdir not set, skipping") } // archive a few files - sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil) - OK(t, repo.Flush()) + sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil) + rtest.OK(t, repo.Flush()) _, err := repo.LoadTree(context.TODO(), *sn.Tree) - OK(t, err) + rtest.OK(t, err) } func BenchmarkLoadTree(t *testing.B) { repo, cleanup := repository.TestRepository(t) defer cleanup() - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { t.Skip("benchdir not set, skipping") } // archive a few files - sn := archiver.TestSnapshot(t, repo, BenchArchiveDirectory, nil) - OK(t, repo.Flush()) + sn := archiver.TestSnapshot(t, repo, rtest.BenchArchiveDirectory, nil) + rtest.OK(t, repo.Flush()) t.ResetTimer() for i := 0; i < t.N; i++ { _, err := repo.LoadTree(context.TODO(), *sn.Tree) - OK(t, err) + rtest.OK(t, err) } } @@ -155,11 +155,11 @@ func TestLoadBlob(t *testing.T) { length := 1000000 buf := restic.NewBlobBuffer(length) _, err := io.ReadFull(rnd, buf) - OK(t, err) + rtest.OK(t, err) id, err := repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{}) - OK(t, err) - OK(t, repo.Flush()) + rtest.OK(t, err) + rtest.OK(t, repo.Flush()) // first, test with buffers that are too small for _, testlength := range []int{length - 20, length, restic.CiphertextLength(length) - 1} { @@ -200,18 +200,18 @@ func BenchmarkLoadBlob(b *testing.B) { length := 1000000 buf := restic.NewBlobBuffer(length) _, err := io.ReadFull(rnd, buf) - OK(b, err) + rtest.OK(b, err) id, err := repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{}) - OK(b, err) - OK(b, repo.Flush()) + rtest.OK(b, err) + rtest.OK(b, repo.Flush()) b.ResetTimer() b.SetBytes(int64(length)) for i := 0; i < b.N; i++ { n, err := repo.LoadBlob(context.TODO(), restic.DataBlob, id, buf) - OK(b, err) + rtest.OK(b, err) if n != length { b.Errorf("wanted %d bytes, got %d", length, n) } @@ -230,20 +230,20 @@ func BenchmarkLoadAndDecrypt(b *testing.B) { length := 1000000 buf := restic.NewBlobBuffer(length) _, err := io.ReadFull(rnd, buf) - OK(b, err) + rtest.OK(b, err) dataID := restic.Hash(buf) storageID, err := repo.SaveUnpacked(context.TODO(), restic.DataFile, buf) - OK(b, err) - // OK(b, repo.Flush()) + rtest.OK(b, err) + // rtest.OK(b, repo.Flush()) b.ResetTimer() b.SetBytes(int64(length)) for i := 0; i < b.N; i++ { data, err := repo.LoadAndDecrypt(context.TODO(), restic.DataFile, storageID) - OK(b, err) + rtest.OK(b, err) if len(data) != length { b.Errorf("wanted %d bytes, got %d", length, len(data)) } @@ -259,7 +259,7 @@ func TestLoadJSONUnpacked(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - if BenchArchiveDirectory == "" { + if rtest.BenchArchiveDirectory == "" { t.Skip("benchdir not set, skipping") } @@ -269,26 +269,26 @@ func TestLoadJSONUnpacked(t *testing.T) { sn.Username = "test!" id, err := repo.SaveJSONUnpacked(context.TODO(), restic.SnapshotFile, &sn) - OK(t, err) + rtest.OK(t, err) var sn2 restic.Snapshot // restore err = repo.LoadJSONUnpacked(context.TODO(), restic.SnapshotFile, id, &sn2) - OK(t, err) + rtest.OK(t, err) - Equals(t, sn.Hostname, sn2.Hostname) - Equals(t, sn.Username, sn2.Username) + rtest.Equals(t, sn.Hostname, sn2.Hostname) + rtest.Equals(t, sn.Username, sn2.Username) } var repoFixture = filepath.Join("testdata", "test-repo.tar.gz") func TestRepositoryLoadIndex(t *testing.T) { - repodir, cleanup := Env(t, repoFixture) + repodir, cleanup := rtest.Env(t, repoFixture) defer cleanup() repo := repository.TestOpenLocal(t, repodir) - OK(t, repo.LoadIndex(context.TODO())) + rtest.OK(t, repo.LoadIndex(context.TODO())) } func BenchmarkLoadIndex(b *testing.B) { @@ -312,18 +312,18 @@ func BenchmarkLoadIndex(b *testing.B) { } id, err := repository.SaveIndex(context.TODO(), repo, idx) - OK(b, err) + rtest.OK(b, err) b.Logf("index saved as %v (%v entries)", id.Str(), idx.Count(restic.DataBlob)) fi, err := repo.Backend().Stat(context.TODO(), restic.Handle{Type: restic.IndexFile, Name: id.String()}) - OK(b, err) + rtest.OK(b, err) b.Logf("filesize is %v", fi.Size) b.ResetTimer() for i := 0; i < b.N; i++ { _, err := repository.LoadIndex(context.TODO(), repo, id) - OK(b, err) + rtest.OK(b, err) } } @@ -334,10 +334,10 @@ func saveRandomDataBlobs(t testing.TB, repo restic.Repository, num int, sizeMax buf := make([]byte, size) _, err := io.ReadFull(rnd, buf) - OK(t, err) + rtest.OK(t, err) _, err = repo.SaveBlob(context.TODO(), restic.DataBlob, buf, restic.ID{}) - OK(t, err) + rtest.OK(t, err) } } @@ -352,26 +352,26 @@ func TestRepositoryIncrementalIndex(t *testing.T) { // add 3 packs, write intermediate index for i := 0; i < 3; i++ { saveRandomDataBlobs(t, repo, 5, 1<<15) - OK(t, repo.Flush()) + rtest.OK(t, repo.Flush()) } - OK(t, repo.SaveFullIndex(context.TODO())) + rtest.OK(t, repo.SaveFullIndex(context.TODO())) } // add another 5 packs for i := 0; i < 5; i++ { saveRandomDataBlobs(t, repo, 5, 1<<15) - OK(t, repo.Flush()) + rtest.OK(t, repo.Flush()) } // save final index - OK(t, repo.SaveIndex(context.TODO())) + rtest.OK(t, repo.SaveIndex(context.TODO())) packEntries := make(map[restic.ID]map[restic.ID]struct{}) for id := range repo.List(context.TODO(), restic.IndexFile) { idx, err := repository.LoadIndex(context.TODO(), repo, id) - OK(t, err) + rtest.OK(t, err) for pb := range idx.Each(context.TODO()) { if _, ok := packEntries[pb.PackID]; !ok { diff --git a/internal/restic/config_test.go b/internal/restic/config_test.go index db06b23f5..dd3ddcc74 100644 --- a/internal/restic/config_test.go +++ b/internal/restic/config_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) type saver func(restic.FileType, interface{}) (restic.ID, error) @@ -23,7 +23,7 @@ func (l loader) LoadJSONUnpacked(ctx context.Context, t restic.FileType, id rest func TestConfig(t *testing.T) { resultConfig := restic.Config{} save := func(tpe restic.FileType, arg interface{}) (restic.ID, error) { - Assert(t, tpe == restic.ConfigFile, + rtest.Assert(t, tpe == restic.ConfigFile, "wrong backend type: got %v, wanted %v", tpe, restic.ConfigFile) @@ -33,12 +33,12 @@ func TestConfig(t *testing.T) { } cfg1, err := restic.CreateConfig() - OK(t, err) + rtest.OK(t, err) _, err = saver(save).SaveJSONUnpacked(restic.ConfigFile, cfg1) load := func(ctx context.Context, tpe restic.FileType, id restic.ID, arg interface{}) error { - Assert(t, tpe == restic.ConfigFile, + rtest.Assert(t, tpe == restic.ConfigFile, "wrong backend type: got %v, wanted %v", tpe, restic.ConfigFile) @@ -48,8 +48,8 @@ func TestConfig(t *testing.T) { } cfg2, err := restic.LoadConfig(context.TODO(), loader(load)) - OK(t, err) + rtest.OK(t, err) - Assert(t, cfg1 == cfg2, + rtest.Assert(t, cfg1 == cfg2, "configs aren't equal: %v != %v", cfg1, cfg2) } diff --git a/internal/restic/hardlinks_index_test.go b/internal/restic/hardlinks_index_test.go index a30456cf0..7e4bcd51a 100644 --- a/internal/restic/hardlinks_index_test.go +++ b/internal/restic/hardlinks_index_test.go @@ -4,7 +4,7 @@ import ( "testing" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) // TestHardLinks contains various tests for HardlinkIndex. @@ -17,19 +17,19 @@ func TestHardLinks(t *testing.T) { var sresult string sresult = idx.GetFilename(1, 2) - Equals(t, sresult, "inode1-file1-on-device2") + rtest.Equals(t, sresult, "inode1-file1-on-device2") sresult = idx.GetFilename(2, 3) - Equals(t, sresult, "inode2-file2-on-device3") + rtest.Equals(t, sresult, "inode2-file2-on-device3") var bresult bool bresult = idx.Has(1, 2) - Equals(t, bresult, true) + rtest.Equals(t, bresult, true) bresult = idx.Has(1, 3) - Equals(t, bresult, false) + rtest.Equals(t, bresult, false) idx.Remove(1, 2) bresult = idx.Has(1, 2) - Equals(t, bresult, false) + rtest.Equals(t, bresult, false) } diff --git a/internal/restic/lock_test.go b/internal/restic/lock_test.go index b0b03abce..a3b4936c9 100644 --- a/internal/restic/lock_test.go +++ b/internal/restic/lock_test.go @@ -8,7 +8,7 @@ import ( "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestLock(t *testing.T) { @@ -16,9 +16,9 @@ func TestLock(t *testing.T) { defer cleanup() lock, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) - OK(t, lock.Unlock()) + rtest.OK(t, lock.Unlock()) } func TestDoubleUnlock(t *testing.T) { @@ -26,12 +26,12 @@ func TestDoubleUnlock(t *testing.T) { defer cleanup() lock, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) - OK(t, lock.Unlock()) + rtest.OK(t, lock.Unlock()) err = lock.Unlock() - Assert(t, err != nil, + rtest.Assert(t, err != nil, "double unlock didn't return an error, got %v", err) } @@ -40,13 +40,13 @@ func TestMultipleLock(t *testing.T) { defer cleanup() lock1, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) lock2, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) - OK(t, lock1.Unlock()) - OK(t, lock2.Unlock()) + rtest.OK(t, lock1.Unlock()) + rtest.OK(t, lock2.Unlock()) } func TestLockExclusive(t *testing.T) { @@ -54,8 +54,8 @@ func TestLockExclusive(t *testing.T) { defer cleanup() elock, err := restic.NewExclusiveLock(context.TODO(), repo) - OK(t, err) - OK(t, elock.Unlock()) + rtest.OK(t, err) + rtest.OK(t, elock.Unlock()) } func TestLockOnExclusiveLockedRepo(t *testing.T) { @@ -63,16 +63,16 @@ func TestLockOnExclusiveLockedRepo(t *testing.T) { defer cleanup() elock, err := restic.NewExclusiveLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) lock, err := restic.NewLock(context.TODO(), repo) - Assert(t, err != nil, + rtest.Assert(t, err != nil, "create normal lock with exclusively locked repo didn't return an error") - Assert(t, restic.IsAlreadyLocked(err), + rtest.Assert(t, restic.IsAlreadyLocked(err), "create normal lock with exclusively locked repo didn't return the correct error") - OK(t, lock.Unlock()) - OK(t, elock.Unlock()) + rtest.OK(t, lock.Unlock()) + rtest.OK(t, elock.Unlock()) } func TestExclusiveLockOnLockedRepo(t *testing.T) { @@ -80,16 +80,16 @@ func TestExclusiveLockOnLockedRepo(t *testing.T) { defer cleanup() elock, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) lock, err := restic.NewExclusiveLock(context.TODO(), repo) - Assert(t, err != nil, + rtest.Assert(t, err != nil, "create normal lock with exclusively locked repo didn't return an error") - Assert(t, restic.IsAlreadyLocked(err), + rtest.Assert(t, restic.IsAlreadyLocked(err), "create normal lock with exclusively locked repo didn't return the correct error") - OK(t, lock.Unlock()) - OK(t, elock.Unlock()) + rtest.OK(t, lock.Unlock()) + rtest.OK(t, elock.Unlock()) } func createFakeLock(repo restic.Repository, t time.Time, pid int) (restic.ID, error) { @@ -141,7 +141,7 @@ var staleLockTests = []struct { func TestLockStale(t *testing.T) { hostname, err := os.Hostname() - OK(t, err) + rtest.OK(t, err) otherHostname := "other-" + hostname @@ -152,12 +152,12 @@ func TestLockStale(t *testing.T) { Hostname: hostname, } - Assert(t, lock.Stale() == test.stale, + rtest.Assert(t, lock.Stale() == test.stale, "TestStaleLock: test %d failed: expected stale: %v, got %v", i, test.stale, !test.stale) lock.Hostname = otherHostname - Assert(t, lock.Stale() == test.staleOnOtherHost, + rtest.Assert(t, lock.Stale() == test.staleOnOtherHost, "TestStaleLock: test %d failed: expected staleOnOtherHost: %v, got %v", i, test.staleOnOtherHost, !test.staleOnOtherHost) } @@ -166,7 +166,7 @@ func TestLockStale(t *testing.T) { func lockExists(repo restic.Repository, t testing.TB, id restic.ID) bool { h := restic.Handle{Type: restic.LockFile, Name: id.String()} exists, err := repo.Backend().Test(context.TODO(), h) - OK(t, err) + rtest.OK(t, err) return exists } @@ -176,24 +176,24 @@ func TestLockWithStaleLock(t *testing.T) { defer cleanup() id1, err := createFakeLock(repo, time.Now().Add(-time.Hour), os.Getpid()) - OK(t, err) + rtest.OK(t, err) id2, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()) - OK(t, err) + rtest.OK(t, err) id3, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()+500000) - OK(t, err) + rtest.OK(t, err) - OK(t, restic.RemoveStaleLocks(context.TODO(), repo)) + rtest.OK(t, restic.RemoveStaleLocks(context.TODO(), repo)) - Assert(t, lockExists(repo, t, id1) == false, + rtest.Assert(t, lockExists(repo, t, id1) == false, "stale lock still exists after RemoveStaleLocks was called") - Assert(t, lockExists(repo, t, id2) == true, + rtest.Assert(t, lockExists(repo, t, id2) == true, "non-stale lock was removed by RemoveStaleLocks") - Assert(t, lockExists(repo, t, id3) == false, + rtest.Assert(t, lockExists(repo, t, id3) == false, "stale lock still exists after RemoveStaleLocks was called") - OK(t, removeLock(repo, id2)) + rtest.OK(t, removeLock(repo, id2)) } func TestRemoveAllLocks(t *testing.T) { @@ -201,21 +201,21 @@ func TestRemoveAllLocks(t *testing.T) { defer cleanup() id1, err := createFakeLock(repo, time.Now().Add(-time.Hour), os.Getpid()) - OK(t, err) + rtest.OK(t, err) id2, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()) - OK(t, err) + rtest.OK(t, err) id3, err := createFakeLock(repo, time.Now().Add(-time.Minute), os.Getpid()+500000) - OK(t, err) + rtest.OK(t, err) - OK(t, restic.RemoveAllLocks(context.TODO(), repo)) + rtest.OK(t, restic.RemoveAllLocks(context.TODO(), repo)) - Assert(t, lockExists(repo, t, id1) == false, + rtest.Assert(t, lockExists(repo, t, id1) == false, "lock still exists after RemoveAllLocks was called") - Assert(t, lockExists(repo, t, id2) == false, + rtest.Assert(t, lockExists(repo, t, id2) == false, "lock still exists after RemoveAllLocks was called") - Assert(t, lockExists(repo, t, id3) == false, + rtest.Assert(t, lockExists(repo, t, id3) == false, "lock still exists after RemoveAllLocks was called") } @@ -224,7 +224,7 @@ func TestLockRefresh(t *testing.T) { defer cleanup() lock, err := restic.NewLock(context.TODO(), repo) - OK(t, err) + rtest.OK(t, err) var lockID *restic.ID for id := range repo.List(context.TODO(), restic.LockFile) { @@ -234,7 +234,7 @@ func TestLockRefresh(t *testing.T) { lockID = &id } - OK(t, lock.Refresh(context.TODO())) + rtest.OK(t, lock.Refresh(context.TODO())) var lockID2 *restic.ID for id := range repo.List(context.TODO(), restic.LockFile) { @@ -244,7 +244,7 @@ func TestLockRefresh(t *testing.T) { lockID2 = &id } - Assert(t, !lockID.Equal(*lockID2), + rtest.Assert(t, !lockID.Equal(*lockID2), "expected a new ID after lock refresh, got the same") - OK(t, lock.Unlock()) + rtest.OK(t, lock.Unlock()) } diff --git a/internal/restic/node_test.go b/internal/restic/node_test.go index 47a9abdb2..6b0a19cd5 100644 --- a/internal/restic/node_test.go +++ b/internal/restic/node_test.go @@ -10,7 +10,7 @@ import ( "time" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func BenchmarkNodeFillUser(t *testing.B) { @@ -32,8 +32,8 @@ func BenchmarkNodeFillUser(t *testing.B) { restic.NodeFromFileInfo(path, fi) } - OK(t, tempfile.Close()) - RemoveAll(t, tempfile.Name()) + rtest.OK(t, tempfile.Close()) + rtest.RemoveAll(t, tempfile.Name()) } func BenchmarkNodeFromFileInfo(t *testing.B) { @@ -58,8 +58,8 @@ func BenchmarkNodeFromFileInfo(t *testing.B) { } } - OK(t, tempfile.Close()) - RemoveAll(t, tempfile.Name()) + rtest.OK(t, tempfile.Close()) + rtest.RemoveAll(t, tempfile.Name()) } func parseTime(s string) time.Time { @@ -166,12 +166,12 @@ var nodeTests = []restic.Node{ } func TestNodeRestoreAt(t *testing.T) { - tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-") - OK(t, err) + tempdir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-") + rtest.OK(t, err) defer func() { - if TestCleanupTempDirs { - RemoveAll(t, tempdir) + if rtest.TestCleanupTempDirs { + rtest.RemoveAll(t, tempdir) } else { t.Logf("leaving tempdir at %v", tempdir) } @@ -181,35 +181,35 @@ func TestNodeRestoreAt(t *testing.T) { for _, test := range nodeTests { nodePath := filepath.Join(tempdir, test.Name) - OK(t, test.CreateAt(context.TODO(), nodePath, nil, idx)) + rtest.OK(t, test.CreateAt(context.TODO(), nodePath, nil, idx)) if test.Type == "symlink" && runtime.GOOS == "windows" { continue } if test.Type == "dir" { - OK(t, test.RestoreTimestamps(nodePath)) + rtest.OK(t, test.RestoreTimestamps(nodePath)) } fi, err := os.Lstat(nodePath) - OK(t, err) + rtest.OK(t, err) n2, err := restic.NodeFromFileInfo(nodePath, fi) - OK(t, err) + rtest.OK(t, err) - Assert(t, test.Name == n2.Name, + rtest.Assert(t, test.Name == n2.Name, "%v: name doesn't match (%v != %v)", test.Type, test.Name, n2.Name) - Assert(t, test.Type == n2.Type, + rtest.Assert(t, test.Type == n2.Type, "%v: type doesn't match (%v != %v)", test.Type, test.Type, n2.Type) - Assert(t, test.Size == n2.Size, + rtest.Assert(t, test.Size == n2.Size, "%v: size doesn't match (%v != %v)", test.Size, test.Size, n2.Size) if runtime.GOOS != "windows" { - Assert(t, test.UID == n2.UID, + rtest.Assert(t, test.UID == n2.UID, "%v: UID doesn't match (%v != %v)", test.Type, test.UID, n2.UID) - Assert(t, test.GID == n2.GID, + rtest.Assert(t, test.GID == n2.GID, "%v: GID doesn't match (%v != %v)", test.Type, test.GID, n2.GID) if test.Type != "symlink" { - Assert(t, test.Mode == n2.Mode, + rtest.Assert(t, test.Mode == n2.Mode, "%v: mode doesn't match (0%o != 0%o)", test.Type, test.Mode, n2.Mode) } } @@ -240,5 +240,5 @@ func AssertFsTimeEqual(t *testing.T, label string, nodeType string, t1 time.Time equal = t1.Equal(t2) } - Assert(t, equal, "%s: %s doesn't match (%v != %v)", label, nodeType, t1, t2) + rtest.Assert(t, equal, "%s: %s doesn't match (%v != %v)", label, nodeType, t1, t2) } diff --git a/internal/restic/snapshot_test.go b/internal/restic/snapshot_test.go index c02970ebb..5e1bf8822 100644 --- a/internal/restic/snapshot_test.go +++ b/internal/restic/snapshot_test.go @@ -5,12 +5,12 @@ import ( "time" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) func TestNewSnapshot(t *testing.T) { paths := []string{"/home/foobar"} _, err := restic.NewSnapshot(paths, nil, "foo", time.Now()) - OK(t, err) + rtest.OK(t, err) } diff --git a/internal/restic/tree_test.go b/internal/restic/tree_test.go index d0d08007b..d1cc8df91 100644 --- a/internal/restic/tree_test.go +++ b/internal/restic/tree_test.go @@ -10,7 +10,7 @@ import ( "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" ) var testFiles = []struct { @@ -23,25 +23,25 @@ var testFiles = []struct { } func createTempDir(t *testing.T) string { - tempdir, err := ioutil.TempDir(TestTempDir, "restic-test-") - OK(t, err) + tempdir, err := ioutil.TempDir(rtest.TestTempDir, "restic-test-") + rtest.OK(t, err) for _, test := range testFiles { file := filepath.Join(tempdir, test.name) dir := filepath.Dir(file) if dir != "." { - OK(t, os.MkdirAll(dir, 0755)) + rtest.OK(t, os.MkdirAll(dir, 0755)) } f, err := os.Create(file) defer func() { - OK(t, f.Close()) + rtest.OK(t, f.Close()) }() - OK(t, err) + rtest.OK(t, err) _, err = f.Write(test.content) - OK(t, err) + rtest.OK(t, err) } return tempdir @@ -50,8 +50,8 @@ func createTempDir(t *testing.T) string { func TestTree(t *testing.T) { dir := createTempDir(t) defer func() { - if TestCleanupTempDirs { - RemoveAll(t, dir) + if rtest.TestCleanupTempDirs { + rtest.RemoveAll(t, dir) } }() } @@ -67,11 +67,11 @@ var testNodes = []restic.Node{ func TestNodeMarshal(t *testing.T) { for i, n := range testNodes { data, err := json.Marshal(&n) - OK(t, err) + rtest.OK(t, err) var node restic.Node err = json.Unmarshal(data, &node) - OK(t, err) + rtest.OK(t, err) if n.Name != node.Name { t.Fatalf("Node %d: Names are not equal, want: %q got: %q", i, n.Name, node.Name) @@ -81,16 +81,16 @@ func TestNodeMarshal(t *testing.T) { func TestNodeComparison(t *testing.T) { fi, err := os.Lstat("tree_test.go") - OK(t, err) + rtest.OK(t, err) node, err := restic.NodeFromFileInfo("tree_test.go", fi) - OK(t, err) + rtest.OK(t, err) n2 := *node - Assert(t, node.Equals(n2), "nodes aren't equal") + rtest.Assert(t, node.Equals(n2), "nodes aren't equal") n2.Size-- - Assert(t, !node.Equals(n2), "nodes are equal") + rtest.Assert(t, !node.Equals(n2), "nodes are equal") } func TestLoadTree(t *testing.T) { @@ -100,16 +100,16 @@ func TestLoadTree(t *testing.T) { // save tree tree := restic.NewTree() id, err := repo.SaveTree(context.TODO(), tree) - OK(t, err) + rtest.OK(t, err) // save packs - OK(t, repo.Flush()) + rtest.OK(t, repo.Flush()) // load tree again tree2, err := repo.LoadTree(context.TODO(), id) - OK(t, err) + rtest.OK(t, err) - Assert(t, tree.Equals(tree2), + rtest.Assert(t, tree.Equals(tree2), "trees are not equal: want %v, got %v", tree, tree2) } diff --git a/internal/walk/walk_test.go b/internal/walk/walk_test.go index 699000292..2e6d4f7cc 100644 --- a/internal/walk/walk_test.go +++ b/internal/walk/walk_test.go @@ -12,7 +12,7 @@ import ( "github.com/restic/restic/internal/pipe" "github.com/restic/restic/internal/repository" "github.com/restic/restic/internal/restic" - . "github.com/restic/restic/internal/test" + rtest "github.com/restic/restic/internal/test" "github.com/restic/restic/internal/walk" ) @@ -20,16 +20,16 @@ func TestWalkTree(t *testing.T) { repo, cleanup := repository.TestRepository(t) defer cleanup() - dirs, err := filepath.Glob(TestWalkerPath) - OK(t, err) + dirs, err := filepath.Glob(rtest.TestWalkerPath) + rtest.OK(t, err) // archive a few files arch := archiver.New(repo) sn, _, err := arch.Snapshot(context.TODO(), nil, dirs, nil, "localhost", nil, time.Now()) - OK(t, err) + rtest.OK(t, err) // flush repo, write all packs - OK(t, repo.Flush()) + rtest.OK(t, repo.Flush()) // start tree walker treeJobs := make(chan walk.TreeJob) @@ -47,10 +47,10 @@ func TestWalkTree(t *testing.T) { for { // receive fs job fsJob, fsChOpen := <-fsJobs - Assert(t, !fsChOpen || fsJob != nil, + rtest.Assert(t, !fsChOpen || fsJob != nil, "received nil job from filesystem: %v %v", fsJob, fsChOpen) if fsJob != nil { - OK(t, fsJob.Error()) + rtest.OK(t, fsJob.Error()) } var path string @@ -67,13 +67,13 @@ func TestWalkTree(t *testing.T) { treeJob, treeChOpen := <-treeJobs treeEntries := 1 - OK(t, treeJob.Error) + rtest.OK(t, treeJob.Error) if treeJob.Tree != nil { treeEntries = len(treeJob.Tree.Nodes) } - Assert(t, fsChOpen == treeChOpen, + rtest.Assert(t, fsChOpen == treeChOpen, "one channel closed too early: fsChOpen %v, treeChOpen %v", fsChOpen, treeChOpen) @@ -81,10 +81,10 @@ func TestWalkTree(t *testing.T) { break } - Assert(t, filepath.Base(path) == filepath.Base(treeJob.Path), + rtest.Assert(t, filepath.Base(path) == filepath.Base(treeJob.Path), "paths do not match: %q != %q", filepath.Base(path), filepath.Base(treeJob.Path)) - Assert(t, fsEntries == treeEntries, + rtest.Assert(t, fsEntries == treeEntries, "wrong number of entries: %v != %v", fsEntries, treeEntries) } } @@ -1340,14 +1340,14 @@ var walktreeTestItems = []string{ } func TestDelayedWalkTree(t *testing.T) { - repodir, cleanup := Env(t, repoFixture) + repodir, cleanup := rtest.Env(t, repoFixture) defer cleanup() repo := repository.TestOpenLocal(t, repodir) - OK(t, repo.LoadIndex(context.TODO())) + rtest.OK(t, repo.LoadIndex(context.TODO())) root, err := restic.ParseID("937a2f64f736c64ee700c6ab06f840c68c94799c288146a0e81e07f4c94254da") - OK(t, err) + rtest.OK(t, err) dr := delayRepo{repo, 100 * time.Millisecond} @@ -1370,14 +1370,14 @@ func TestDelayedWalkTree(t *testing.T) { } func BenchmarkDelayedWalkTree(t *testing.B) { - repodir, cleanup := Env(t, repoFixture) + repodir, cleanup := rtest.Env(t, repoFixture) defer cleanup() repo := repository.TestOpenLocal(t, repodir) - OK(t, repo.LoadIndex(context.TODO())) + rtest.OK(t, repo.LoadIndex(context.TODO())) root, err := restic.ParseID("937a2f64f736c64ee700c6ab06f840c68c94799c288146a0e81e07f4c94254da") - OK(t, err) + rtest.OK(t, err) dr := delayRepo{repo, 10 * time.Millisecond}