Merge pull request #701 from Juneezee/test/t.TempDir

controllers/bucket_controller_fetch_test.go

@@ -107,11 +107,7 @@ func Test_fetchEtagIndex(t *testing.T) {
 	}
 
 	t.Run("fetches etag index", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject("foo.yaml", mockBucketObject{data: "foo.yaml", etag: "etag1"})
@@ -119,7 +115,7 @@ func Test_fetchEtagIndex(t *testing.T) {
 		client.addObject("baz.yaml", mockBucketObject{data: "baz.yaml", etag: "etag3"})
 
 		index := newEtagIndex()
-		err = fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -128,25 +124,17 @@ func Test_fetchEtagIndex(t *testing.T) {
 	})
 
 	t.Run("an error while bucket does not exist", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: "other-bucket-name"}
 
 		index := newEtagIndex()
-		err = fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		assert.ErrorContains(t, err, "not found")
 	})
 
 	t.Run("filters with .sourceignore rules", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject(".sourceignore", mockBucketObject{etag: "sourceignore1", data: `*.txt`})
@@ -154,7 +142,7 @@ func Test_fetchEtagIndex(t *testing.T) {
 		client.addObject("foo.txt", mockBucketObject{etag: "etag2", data: "foo.txt"})
 
 		index := newEtagIndex()
-		err = fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -170,11 +158,7 @@ func Test_fetchEtagIndex(t *testing.T) {
 	})
 
 	t.Run("filters with ignore rules from object", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject(".sourceignore", mockBucketObject{etag: "sourceignore1", data: `*.txt`})
@@ -185,7 +169,7 @@ func Test_fetchEtagIndex(t *testing.T) {
 		bucket.Spec.Ignore = &ignore
 
 		index := newEtagIndex()
-		err = fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchEtagIndex(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -212,11 +196,7 @@ func Test_fetchFiles(t *testing.T) {
 	}
 
 	t.Run("fetches files", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject("foo.yaml", mockBucketObject{data: "foo.yaml", etag: "etag1"})
@@ -225,7 +205,7 @@ func Test_fetchFiles(t *testing.T) {
 
 		index := client.objectsToEtagIndex()
 
-		err = fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -240,34 +220,26 @@ func Test_fetchFiles(t *testing.T) {
 	})
 
 	t.Run("an error while fetching returns an error for the whole procedure", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName, objects: map[string]mockBucketObject{}}
 		client.objects["error"] = mockBucketObject{}
 
-		err = fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), client.objectsToEtagIndex(), tmp)
+		err := fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), client.objectsToEtagIndex(), tmp)
 		if err == nil {
 			t.Fatal("expected error but got nil")
 		}
 	})
 
 	t.Run("a changed etag updates the index", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject("foo.yaml", mockBucketObject{data: "foo.yaml", etag: "etag2"})
 
 		index := newEtagIndex()
 		index.Add("foo.yaml", "etag1")
-		err = fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -276,11 +248,7 @@ func Test_fetchFiles(t *testing.T) {
 	})
 
 	t.Run("a disappeared index entry is removed from the index", func(t *testing.T) {
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		client.addObject("foo.yaml", mockBucketObject{data: "foo.yaml", etag: "etag1"})
@@ -290,7 +258,7 @@ func Test_fetchFiles(t *testing.T) {
 		// Does not exist on server
 		index.Add("bar.yaml", "etag2")
 
-		err = fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -301,11 +269,7 @@ func Test_fetchFiles(t *testing.T) {
 
 	t.Run("can fetch more than maxConcurrentFetches", func(t *testing.T) {
 		// this will fail if, for example, the semaphore is not used correctly and blocks
-		tmp, err := os.MkdirTemp("", "test-bucket")
+		tmp := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tmp)
 
 		client := mockBucketClient{bucketName: bucketName}
 		for i := 0; i < 2*maxConcurrentBucketFetches; i++ {
@@ -314,7 +278,7 @@ func Test_fetchFiles(t *testing.T) {
 		}
 		index := client.objectsToEtagIndex()
 
-		err = fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
+		err := fetchIndexFiles(context.TODO(), client, bucket.DeepCopy(), index, tmp)
 		if err != nil {
 			t.Fatal(err)
 		}

controllers/bucket_controller_test.go

@@ -539,9 +539,7 @@ func TestBucketReconciler_reconcileSource_generic(t *testing.T) {
 				Client:        builder.Build(),
 				Storage:       testStorage,
 			}
-			tmpDir, err := os.MkdirTemp("", "reconcile-bucket-source-")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			obj := &sourcev1.Bucket{
 				TypeMeta: metav1.TypeMeta{
@@ -834,9 +832,7 @@ func TestBucketReconciler_reconcileSource_gcs(t *testing.T) {
 				Client:        builder.Build(),
 				Storage:       testStorage,
 			}
-			tmpDir, err := os.MkdirTemp("", "reconcile-bucket-source-")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			// Test bucket object.
 			obj := &sourcev1.Bucket{
@@ -992,9 +988,7 @@ func TestBucketReconciler_reconcileArtifact(t *testing.T) {
 				Storage:       testStorage,
 			}
 
-			tmpDir, err := os.MkdirTemp("", "reconcile-bucket-artifact-")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			obj := &sourcev1.Bucket{
 				TypeMeta: metav1.TypeMeta{

controllers/gitrepository_controller_test.go

@@ -509,9 +509,7 @@ func TestGitRepositoryReconciler_reconcileSource_authStrategy(t *testing.T) {
 						t.Skipf("Skipped for Git implementation %q", i)
 					}
 
-					tmpDir, err := os.MkdirTemp("", "auth-strategy-")
+					tmpDir := t.TempDir()
-					g.Expect(err).To(BeNil())
-					defer os.RemoveAll(tmpDir)
 
 					obj := obj.DeepCopy()
 					obj.Spec.GitImplementation = i
@@ -671,9 +669,7 @@ func TestGitRepositoryReconciler_reconcileSource_checkoutStrategy(t *testing.T)
 						t.Skipf("Skipped for Git implementation %q", i)
 					}
 
-					tmpDir, err := os.MkdirTemp("", "checkout-strategy-")
+					tmpDir := t.TempDir()
-					g.Expect(err).NotTo(HaveOccurred())
-					defer os.RemoveAll(tmpDir)
 
 					obj := obj.DeepCopy()
 					obj.Spec.GitImplementation = i
@@ -1072,9 +1068,7 @@ func TestGitRepositoryReconciler_reconcileInclude(t *testing.T) {
 				tt.beforeFunc(obj)
 			}
 
-			tmpDir, err := os.MkdirTemp("", "include-")
+			tmpDir := t.TempDir()
-			g.Expect(err).NotTo(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			var commit git.Commit
 			var includes artifactSet

controllers/helmchart_controller_test.go

@@ -307,9 +307,7 @@ func TestHelmChartReconciler_reconcileStorage(t *testing.T) {
 func TestHelmChartReconciler_reconcileSource(t *testing.T) {
 	g := NewWithT(t)
 
-	tmpDir, err := os.MkdirTemp("", "reconcile-tarball-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 
 	storage, err := NewStorage(tmpDir, "example.com", retentionTTL, retentionRecords)
 	g.Expect(err).ToNot(HaveOccurred())
@@ -781,9 +779,7 @@ func TestHelmChartReconciler_buildFromHelmRepository(t *testing.T) {
 func TestHelmChartReconciler_buildFromTarballArtifact(t *testing.T) {
 	g := NewWithT(t)
 
-	tmpDir, err := os.MkdirTemp("", "reconcile-tarball-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 
 	storage, err := NewStorage(tmpDir, "example.com", retentionTTL, retentionRecords)
 	g.Expect(err).ToNot(HaveOccurred())

controllers/helmrepository_controller_test.go

@@ -728,9 +728,7 @@ func TestHelmRepositoryReconciler_reconcileArtifact(t *testing.T) {
 				},
 			}
 
-			tmpDir, err := os.MkdirTemp("", "test-reconcile-artifact-")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			// Create an empty cache file.
 			cachePath := filepath.Join(tmpDir, "index.yaml")

controllers/storage_test.go

@@ -35,20 +35,8 @@ import (
 	sourcev1 "github.com/fluxcd/source-controller/api/v1beta2"
 )
 
-func createStoragePath() (string, error) {
-	return os.MkdirTemp("", "")
-}
-
-func cleanupStoragePath(dir string) func() {
-	return func() { os.RemoveAll(dir) }
-}
-
 func TestStorageConstructor(t *testing.T) {
-	dir, err := createStoragePath()
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanupStoragePath(dir))
 
 	if _, err := NewStorage("/nonexistent", "hostname", time.Minute, 2); err == nil {
 		t.Fatal("nonexistent path was allowable in storage constructor")
@@ -113,11 +101,7 @@ func walkTar(tarFile string, match string, dir bool) (int64, bool, error) {
 }
 
 func TestStorage_Archive(t *testing.T) {
-	dir, err := createStoragePath()
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanupStoragePath(dir))
 
 	storage, err := NewStorage(dir, "hostname", time.Minute, 2)
 	if err != nil {
@@ -125,15 +109,7 @@ func TestStorage_Archive(t *testing.T) {
 	}
 
 	createFiles := func(files map[string][]byte) (dir string, err error) {
-		defer func() {
+		dir = t.TempDir()
-			if err != nil && dir != "" {
-				os.RemoveAll(dir)
-			}
-		}()
-		dir, err = os.MkdirTemp("", "archive-test-files-")
-		if err != nil {
-			return
-		}
 		for name, b := range files {
 			absPath := filepath.Join(dir, name)
 			if err = os.MkdirAll(filepath.Dir(absPath), 0o750); err != nil {
@@ -285,11 +261,7 @@ func TestStorage_Archive(t *testing.T) {
 
 func TestStorageRemoveAllButCurrent(t *testing.T) {
 	t.Run("bad directory in archive", func(t *testing.T) {
-		dir, err := os.MkdirTemp("", "")
+		dir := t.TempDir()
-		if err != nil {
-			t.Fatal(err)
-		}
-		t.Cleanup(func() { os.RemoveAll(dir) })
 
 		s, err := NewStorage(dir, "hostname", time.Minute, 2)
 		if err != nil {
@@ -303,9 +275,7 @@ func TestStorageRemoveAllButCurrent(t *testing.T) {
 
 	t.Run("collect names of deleted items", func(t *testing.T) {
 		g := NewWithT(t)
-		dir, err := os.MkdirTemp("", "")
+		dir := t.TempDir()
-		g.Expect(err).ToNot(HaveOccurred())
-		t.Cleanup(func() { os.RemoveAll(dir) })
 
 		s, err := NewStorage(dir, "hostname", time.Minute, 2)
 		g.Expect(err).ToNot(HaveOccurred(), "failed to create new storage")
@@ -366,9 +336,7 @@ func TestStorageRemoveAll(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
-			dir, err := os.MkdirTemp("", "")
+			dir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			t.Cleanup(func() { os.RemoveAll(dir) })
 
 			s, err := NewStorage(dir, "hostname", time.Minute, 2)
 			g.Expect(err).ToNot(HaveOccurred(), "failed to create new storage")
@@ -394,11 +362,7 @@ func TestStorageCopyFromPath(t *testing.T) {
 		Content []byte
 	}
 
-	dir, err := createStoragePath()
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(cleanupStoragePath(dir))
 
 	storage, err := NewStorage(dir, "hostname", time.Minute, 2)
 	if err != nil {
@@ -406,11 +370,7 @@ func TestStorageCopyFromPath(t *testing.T) {
 	}
 
 	createFile := func(file *File) (absPath string, err error) {
-		dir, err = os.MkdirTemp("", "test-files-")
+		dir = t.TempDir()
-		if err != nil {
-			return
-		}
-		t.Cleanup(cleanupStoragePath(dir))
 		absPath = filepath.Join(dir, file.Name)
 		if err = os.MkdirAll(filepath.Dir(absPath), 0o750); err != nil {
 			return
@@ -474,7 +434,6 @@ func TestStorageCopyFromPath(t *testing.T) {
 				t.Error(err)
 				return
 			}
-			defer os.RemoveAll(absPath)
 			artifact := sourcev1.Artifact{
 				Path: filepath.Join(randStringRunes(10), randStringRunes(10), randStringRunes(10)),
 			}
@@ -581,9 +540,7 @@ func TestStorage_getGarbageFiles(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
-			dir, err := os.MkdirTemp("", "")
+			dir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			t.Cleanup(func() { os.RemoveAll(dir) })
 
 			s, err := NewStorage(dir, "hostname", tt.ttl, tt.maxItemsToBeRetained)
 			g.Expect(err).ToNot(HaveOccurred(), "failed to create new storage")
@@ -657,9 +614,7 @@ func TestStorage_GarbageCollect(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
-			dir, err := os.MkdirTemp("", "")
+			dir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			t.Cleanup(func() { os.RemoveAll(dir) })
 
 			s, err := NewStorage(dir, "hostname", time.Second*2, 2)
 			g.Expect(err).ToNot(HaveOccurred(), "failed to create new storage")

internal/fs/fs_test.go

@@ -19,13 +19,9 @@ var (
 )
 
 func TestRenameWithFallback(t *testing.T) {
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
-	if err = RenameWithFallback(filepath.Join(dir, "does_not_exists"), filepath.Join(dir, "dst")); err == nil {
+	if err := RenameWithFallback(filepath.Join(dir, "does_not_exists"), filepath.Join(dir, "dst")); err == nil {
 		t.Fatal("expected an error for non existing file, but got nil")
 	}
 
@@ -37,31 +33,27 @@ func TestRenameWithFallback(t *testing.T) {
 		srcf.Close()
 	}
 
-	if err = RenameWithFallback(srcpath, filepath.Join(dir, "dst")); err != nil {
+	if err := RenameWithFallback(srcpath, filepath.Join(dir, "dst")); err != nil {
 		t.Fatal(err)
 	}
 
 	srcpath = filepath.Join(dir, "a")
-	if err = os.MkdirAll(srcpath, 0o770); err != nil {
+	if err := os.MkdirAll(srcpath, 0o770); err != nil {
 		t.Fatal(err)
 	}
 
 	dstpath := filepath.Join(dir, "b")
-	if err = os.MkdirAll(dstpath, 0o770); err != nil {
+	if err := os.MkdirAll(dstpath, 0o770); err != nil {
 		t.Fatal(err)
 	}
 
-	if err = RenameWithFallback(srcpath, dstpath); err == nil {
+	if err := RenameWithFallback(srcpath, dstpath); err == nil {
 		t.Fatal("expected an error if dst is an existing directory, but got nil")
 	}
 }
 
 func TestCopyDir(t *testing.T) {
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcdir := filepath.Join(dir, "src")
 	if err := os.MkdirAll(srcdir, 0o750); err != nil {
@@ -81,7 +73,7 @@ func TestCopyDir(t *testing.T) {
 	for i, file := range files {
 		fn := filepath.Join(srcdir, file.path)
 		dn := filepath.Dir(fn)
-		if err = os.MkdirAll(dn, 0o750); err != nil {
+		if err := os.MkdirAll(dn, 0o750); err != nil {
 			t.Fatal(err)
 		}
 
@@ -149,20 +141,15 @@ func TestCopyDirFail_SrcInaccessible(t *testing.T) {
 
 	var srcdir, dstdir string
 
-	cleanup := setupInaccessibleDir(t, func(dir string) error {
+	setupInaccessibleDir(t, func(dir string) error {
 		srcdir = filepath.Join(dir, "src")
 		return os.MkdirAll(srcdir, 0o750)
 	})
-	defer cleanup()
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	dstdir = filepath.Join(dir, "dst")
-	if err = CopyDir(srcdir, dstdir); err == nil {
+	if err := CopyDir(srcdir, dstdir); err == nil {
 		t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
 	}
 }
@@ -177,22 +164,17 @@ func TestCopyDirFail_DstInaccessible(t *testing.T) {
 
 	var srcdir, dstdir string
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcdir = filepath.Join(dir, "src")
-	if err = os.MkdirAll(srcdir, 0o750); err != nil {
+	if err := os.MkdirAll(srcdir, 0o750); err != nil {
 		t.Fatal(err)
 	}
 
-	cleanup := setupInaccessibleDir(t, func(dir string) error {
+	setupInaccessibleDir(t, func(dir string) error {
 		dstdir = filepath.Join(dir, "dst")
 		return nil
 	})
-	defer cleanup()
 
 	if err := CopyDir(srcdir, dstdir); err == nil {
 		t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
@@ -202,20 +184,17 @@ func TestCopyDirFail_DstInaccessible(t *testing.T) {
 func TestCopyDirFail_SrcIsNotDir(t *testing.T) {
 	var srcdir, dstdir string
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcdir = filepath.Join(dir, "src")
-	if _, err = os.Create(srcdir); err != nil {
+	if _, err := os.Create(srcdir); err != nil {
 		t.Fatal(err)
 	}
 
 	dstdir = filepath.Join(dir, "dst")
 
-	if err = CopyDir(srcdir, dstdir); err == nil {
+	err := CopyDir(srcdir, dstdir)
+	if err == nil {
 		t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
 	}
 
@@ -228,23 +207,20 @@ func TestCopyDirFail_SrcIsNotDir(t *testing.T) {
 func TestCopyDirFail_DstExists(t *testing.T) {
 	var srcdir, dstdir string
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcdir = filepath.Join(dir, "src")
-	if err = os.MkdirAll(srcdir, 0o750); err != nil {
+	if err := os.MkdirAll(srcdir, 0o750); err != nil {
 		t.Fatal(err)
 	}
 
 	dstdir = filepath.Join(dir, "dst")
-	if err = os.MkdirAll(dstdir, 0o750); err != nil {
+	if err := os.MkdirAll(dstdir, 0o750); err != nil {
 		t.Fatal(err)
 	}
 
-	if err = CopyDir(srcdir, dstdir); err == nil {
+	err := CopyDir(srcdir, dstdir)
+	if err == nil {
 		t.Fatalf("expected error for CopyDir(%s, %s), got none", srcdir, dstdir)
 	}
 
@@ -266,14 +242,10 @@ func TestCopyDirFailOpen(t *testing.T) {
 
 	var srcdir, dstdir string
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcdir = filepath.Join(dir, "src")
-	if err = os.MkdirAll(srcdir, 0o750); err != nil {
+	if err := os.MkdirAll(srcdir, 0o750); err != nil {
 		t.Fatal(err)
 	}
 
@@ -297,11 +269,7 @@ func TestCopyDirFailOpen(t *testing.T) {
 }
 
 func TestCopyFile(t *testing.T) {
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcf, err := os.Create(filepath.Join(dir, "srcfile"))
 	if err != nil {
@@ -344,10 +312,7 @@ func TestCopyFile(t *testing.T) {
 }
 
 func TestCopyFileSymlink(t *testing.T) {
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
 	defer cleanUpDir(dir)
 
 	testcases := map[string]string{
@@ -406,11 +371,7 @@ func TestCopyFileLongFilePath(t *testing.T) {
 		t.Skip("skipping on non-windows")
 	}
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer cleanUpDir(dir)
 
 	// Create a directory with a long-enough path name to cause the bug in #774.
 	dirName := ""
@@ -423,7 +384,7 @@ func TestCopyFileLongFilePath(t *testing.T) {
 		t.Fatalf("%+v", fmt.Errorf("unable to create temp directory: %s", fullPath))
 	}
 
-	err = os.WriteFile(fullPath+"src", []byte(nil), 0o640)
+	err := os.WriteFile(fullPath+"src", []byte(nil), 0o640)
 	if err != nil {
 		t.Fatalf("%+v", err)
 	}
@@ -444,11 +405,7 @@ func TestCopyFileFail(t *testing.T) {
 		t.Skip("skipping on windows")
 	}
 
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	srcf, err := os.Create(filepath.Join(dir, "srcfile"))
 	if err != nil {
@@ -458,11 +415,10 @@ func TestCopyFileFail(t *testing.T) {
 
 	var dstdir string
 
-	cleanup := setupInaccessibleDir(t, func(dir string) error {
+	setupInaccessibleDir(t, func(dir string) error {
 		dstdir = filepath.Join(dir, "dir")
 		return os.Mkdir(dstdir, 0o770)
 	})
-	defer cleanup()
 
 	fn := filepath.Join(dstdir, "file")
 	if err := copyFile(srcf.Name(), fn); err == nil {
@@ -479,47 +435,31 @@ func TestCopyFileFail(t *testing.T) {
 //
 // If setupInaccessibleDir fails in its preparation, or op fails, t.Fatal
 // will be invoked.
-//
+func setupInaccessibleDir(t *testing.T, op func(dir string) error) {
-// This function returns a cleanup function that removes all the temporary
-// files this function creates. It is the caller's responsibility to call
-// this function before the test is done running, whether there's an error or not.
-func setupInaccessibleDir(t *testing.T, op func(dir string) error) func() {
 	dir, err := os.MkdirTemp("", "dep")
 	if err != nil {
 		t.Fatal(err)
-		return nil // keep compiler happy
 	}
 
 	subdir := filepath.Join(dir, "dir")
 
-	cleanup := func() {
+	t.Cleanup(func() {
 		if err := os.Chmod(subdir, 0o770); err != nil {
 			t.Error(err)
 		}
-		if err := os.RemoveAll(dir); err != nil {
+	})
-			t.Error(err)
-		}
-	}
 
 	if err := os.Mkdir(subdir, 0o770); err != nil {
-		cleanup()
 		t.Fatal(err)
-		return nil
 	}
 
 	if err := op(subdir); err != nil {
-		cleanup()
 		t.Fatal(err)
-		return nil
 	}
 
 	if err := os.Chmod(subdir, 0o660); err != nil {
-		cleanup()
 		t.Fatal(err)
-		return nil
 	}
-
-	return cleanup
 }
 
 func TestIsDir(t *testing.T) {
@@ -530,11 +470,10 @@ func TestIsDir(t *testing.T) {
 
 	var dn string
 
-	cleanup := setupInaccessibleDir(t, func(dir string) error {
+	setupInaccessibleDir(t, func(dir string) error {
 		dn = filepath.Join(dir, "dir")
 		return os.Mkdir(dn, 0o770)
 	})
-	defer cleanup()
 
 	tests := map[string]struct {
 		exists bool
@@ -568,14 +507,10 @@ func TestIsDir(t *testing.T) {
 }
 
 func TestIsSymlink(t *testing.T) {
-	dir, err := os.MkdirTemp("", "dep")
+	dir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(dir)
 
 	dirPath := filepath.Join(dir, "directory")
-	if err = os.MkdirAll(dirPath, 0o770); err != nil {
+	if err := os.MkdirAll(dirPath, 0o770); err != nil {
 		t.Fatal(err)
 	}
 
@@ -601,7 +536,7 @@ func TestIsSymlink(t *testing.T) {
 		inaccessibleSymlink string
 	)
 
-	cleanup := setupInaccessibleDir(t, func(dir string) error {
+	setupInaccessibleDir(t, func(dir string) error {
 		inaccessibleFile = filepath.Join(dir, "file")
 		if fh, err := os.Create(inaccessibleFile); err != nil {
 			return err
@@ -612,7 +547,6 @@ func TestIsSymlink(t *testing.T) {
 		inaccessibleSymlink = filepath.Join(dir, "symlink")
 		return os.Symlink(inaccessibleFile, inaccessibleSymlink)
 	})
-	defer cleanup()
 
 	tests := map[string]struct{ expected, err bool }{
 		dirPath:             {false, false},

internal/helm/chart/builder_local_test.go

@@ -177,9 +177,7 @@ fullnameOverride: "full-foo-name-override"`),
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			workDir, err := os.MkdirTemp("", "local-builder-")
+			workDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(workDir)
 
 			// Only if the reference is a LocalReference, set the WorkDir.
 			localRef, ok := tt.reference.(LocalReference)
@@ -213,7 +211,6 @@ fullnameOverride: "full-foo-name-override"`),
 
 			// Target path with name similar to the workDir.
 			targetPath := workDir + ".tgz"
-			defer os.RemoveAll(targetPath)
 
 			dm := NewDependencyManager(
 				WithRepositories(tt.repositories),
@@ -247,18 +244,14 @@ fullnameOverride: "full-foo-name-override"`),
 func TestLocalBuilder_Build_CachedChart(t *testing.T) {
 	g := NewWithT(t)
 
-	workDir, err := os.MkdirTemp("", "local-builder-")
+	workDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(workDir)
 
 	testChartPath := "./../testdata/charts/helmchart"
 
 	dm := NewDependencyManager()
 	b := NewLocalBuilder(dm)
 
-	tmpDir, err := os.MkdirTemp("", "local-chart-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 
 	// Copy the source chart into the workdir.
 	g.Expect(copy.Copy(testChartPath, filepath.Join(workDir, "testdata", "charts", filepath.Base("helmchart")))).ToNot(HaveOccurred())
@@ -275,7 +268,6 @@ func TestLocalBuilder_Build_CachedChart(t *testing.T) {
 	buildOpts.CachedChart = cb.Path
 
 	targetPath2 := filepath.Join(tmpDir, "chart2.tgz")
-	defer os.RemoveAll(targetPath2)
 	cb, err = b.Build(context.TODO(), reference, targetPath2, buildOpts)
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(cb.Path).To(Equal(targetPath))
@@ -331,9 +323,7 @@ func Test_mergeFileValues(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			baseDir, err := os.MkdirTemp("", "merge-file-values-*")
+			baseDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(baseDir)
 
 			for _, f := range tt.files {
 				g.Expect(os.WriteFile(filepath.Join(baseDir, f.Name), f.Data, 0o640)).To(Succeed())

internal/helm/chart/builder_remote_test.go

@@ -159,9 +159,7 @@ entries:
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			tmpDir, err := os.MkdirTemp("", "remote-chart-builder-")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 			targetPath := filepath.Join(tmpDir, "chart.tgz")
 
 			if tt.repository != nil {
@@ -237,13 +235,10 @@ entries:
 
 	b := NewRemoteBuilder(repository)
 
-	tmpDir, err := os.MkdirTemp("", "remote-chart-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 
 	// Build first time.
 	targetPath := filepath.Join(tmpDir, "chart1.tgz")
-	defer os.RemoveAll(targetPath)
 	buildOpts := BuildOptions{}
 	cb, err := b.Build(context.TODO(), reference, targetPath, buildOpts)
 	g.Expect(err).ToNot(HaveOccurred())
@@ -253,7 +248,6 @@ entries:
 
 	// Rebuild with a new path.
 	targetPath2 := filepath.Join(tmpDir, "chart2.tgz")
-	defer os.RemoveAll(targetPath2)
 	cb, err = b.Build(context.TODO(), reference, targetPath2, buildOpts)
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(cb.Path).To(Equal(targetPath))
@@ -342,16 +336,13 @@ func Test_mergeChartValues(t *testing.T) {
 func Test_validatePackageAndWriteToPath(t *testing.T) {
 	g := NewWithT(t)
 
-	tmpDir, err := os.MkdirTemp("", "validate-pkg-chart-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 
 	validF, err := os.Open("./../testdata/charts/helmchart-0.1.0.tgz")
 	g.Expect(err).ToNot(HaveOccurred())
 	defer validF.Close()
 
 	chartPath := filepath.Join(tmpDir, "chart.tgz")
-	defer os.Remove(chartPath)
 	err = validatePackageAndWriteToPath(validF, chartPath)
 	g.Expect(err).ToNot(HaveOccurred())
 	g.Expect(chartPath).To(BeARegularFile())

internal/helm/chart/metadata_test.go

@@ -134,9 +134,7 @@ func TestLoadChartMetadataFromDir(t *testing.T) {
 	g := NewWithT(t)
 
 	// Create a chart file that exceeds the max chart file size.
-	tmpDir, err := os.MkdirTemp("", "load-chart-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 	copy.Copy("../testdata/charts/helmchart", tmpDir)
 	bigRequirementsFile := filepath.Join(tmpDir, "requirements.yaml")
 	data := make([]byte, helm.MaxChartFileSize+10)
@@ -200,9 +198,7 @@ func TestLoadChartMetadataFromArchive(t *testing.T) {
 	g := NewWithT(t)
 
 	// Create a chart archive that exceeds the max chart size.
-	tmpDir, err := os.MkdirTemp("", "load-chart-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 	bigArchiveFile := filepath.Join(tmpDir, "chart.tgz")
 	data := make([]byte, helm.MaxChartSize+10)
 	g.Expect(os.WriteFile(bigArchiveFile, data, 0o640)).ToNot(HaveOccurred())

internal/helm/repository/chart_repository_test.go

@@ -358,9 +358,7 @@ func TestChartRepository_LoadIndexFromFile(t *testing.T) {
 	g := NewWithT(t)
 
 	// Create an index file that exceeds the max index size.
-	tmpDir, err := os.MkdirTemp("", "load-index-")
+	tmpDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(tmpDir)
 	bigIndexFile := filepath.Join(tmpDir, "index.yaml")
 	data := make([]byte, helm.MaxIndexSize+10)
 	g.Expect(os.WriteFile(bigIndexFile, data, 0o640)).ToNot(HaveOccurred())

pkg/gcp/gcp_test.go

@@ -202,9 +202,7 @@ func TestVisitObjectsCallbackErr(t *testing.T) {
 }
 
 func TestFGetObject(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", bucketName)
+	tempDir := t.TempDir()
-	assert.NilError(t, err)
-	defer os.RemoveAll(tempDir)
 	gcpClient := &GCSClient{
 		Client: client,
 	}
@@ -218,9 +216,7 @@ func TestFGetObject(t *testing.T) {
 
 func TestFGetObjectNotExists(t *testing.T) {
 	object := "notexists.txt"
-	tempDir, err := os.MkdirTemp("", bucketName)
+	tempDir := t.TempDir()
-	assert.NilError(t, err)
-	defer os.RemoveAll(tempDir)
 	gcsClient := &GCSClient{
 		Client: client,
 	}
@@ -233,9 +229,7 @@ func TestFGetObjectNotExists(t *testing.T) {
 }
 
 func TestFGetObjectDirectoryIsFileName(t *testing.T) {
-	tempDir, err := os.MkdirTemp("", bucketName)
+	tempDir := t.TempDir()
-	assert.NilError(t, err)
-	defer os.RemoveAll(tempDir)
 	gcpClient := &GCSClient{
 		Client: client,
 	}

pkg/git/gogit/checkout_test.go

@@ -35,11 +35,10 @@ import (
 )
 
 func TestCheckoutBranch_Checkout(t *testing.T) {
-	repo, path, err := initRepo()
+	repo, path, err := initRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer os.RemoveAll(path)
 
 	firstCommit, err := commitFile(repo, "branch", "init", time.Now())
 	if err != nil {
@@ -88,8 +87,7 @@ func TestCheckoutBranch_Checkout(t *testing.T) {
 			branch := CheckoutBranch{
 				Branch: tt.branch,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := branch.Checkout(context.TODO(), tmpDir, path, nil)
 			if tt.expectedErr != "" {
@@ -142,11 +140,10 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			repo, path, err := initRepo()
+			repo, path, err := initRepo(t)
 			if err != nil {
 				t.Fatal(err)
 			}
-			defer os.RemoveAll(path)
 
 			var h plumbing.Hash
 			if tt.tag != "" {
@@ -163,8 +160,7 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 			tag := CheckoutTag{
 				Tag: tt.checkoutTag,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := tag.Checkout(context.TODO(), tmpDir, path, nil)
 			if tt.expectErr != "" {
@@ -182,11 +178,10 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 }
 
 func TestCheckoutCommit_Checkout(t *testing.T) {
-	repo, path, err := initRepo()
+	repo, path, err := initRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer os.RemoveAll(path)
 
 	firstCommit, err := commitFile(repo, "commit", "init", time.Now())
 	if err != nil {
@@ -242,11 +237,7 @@ func TestCheckoutCommit_Checkout(t *testing.T) {
 				Branch: tt.branch,
 			}
 
-			tmpDir, err := os.MkdirTemp("", "git2go")
+			tmpDir := t.TempDir()
-			if err != nil {
-				t.Fatal(err)
-			}
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := commit.Checkout(context.TODO(), tmpDir, path, nil)
 			if tt.expectError != "" {
@@ -326,11 +317,10 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 		},
 	}
 
-	repo, path, err := initRepo()
+	repo, path, err := initRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer os.RemoveAll(path)
 
 	refs := make(map[string]string, len(tags))
 	for _, tt := range tags {
@@ -352,8 +342,7 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 			semVer := CheckoutSemVer{
 				SemVer: tt.constraint,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := semVer.Checkout(context.TODO(), tmpDir, path, nil)
 			if tt.expectErr != nil {
@@ -370,16 +359,11 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 	}
 }
 
-func initRepo() (*extgogit.Repository, string, error) {
+func initRepo(t *testing.T) (*extgogit.Repository, string, error) {
-	tmpDir, err := os.MkdirTemp("", "gogit")
+	tmpDir := t.TempDir()
-	if err != nil {
-		os.RemoveAll(tmpDir)
-		return nil, "", err
-	}
 	sto := filesystem.NewStorage(osfs.New(tmpDir), cache.NewObjectLRUDefault())
 	repo, err := extgogit.Init(sto, memfs.New())
 	if err != nil {
-		os.RemoveAll(tmpDir)
 		return nil, "", err
 	}
 	return repo, tmpDir, err

pkg/git/libgit2/checkout_test.go

@@ -37,12 +37,11 @@ import (
 )
 
 func TestCheckoutBranch_Checkout(t *testing.T) {
-	repo, err := initBareRepo()
+	repo, err := initBareRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer repo.Free()
-	defer os.RemoveAll(filepath.Join(repo.Path(), ".."))
 
 	cfg, err := git2go.OpenDefault()
 	if err != nil {
@@ -105,8 +104,7 @@ func TestCheckoutBranch_Checkout(t *testing.T) {
 			branch := CheckoutBranch{
 				Branch: tt.branch,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := branch.Checkout(context.TODO(), tmpDir, repo.Path(), nil)
 			if tt.expectedErr != "" {
@@ -158,12 +156,11 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			repo, err := initBareRepo()
+			repo, err := initBareRepo(t)
 			if err != nil {
 				t.Fatal(err)
 			}
 			defer repo.Free()
-			defer os.RemoveAll(filepath.Join(repo.Path(), ".."))
 
 			var commit *git2go.Commit
 			if tt.tag != "" {
@@ -183,8 +180,7 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 			tag := CheckoutTag{
 				Tag: tt.checkoutTag,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := tag.Checkout(context.TODO(), tmpDir, repo.Path(), nil)
 			if tt.expectErr != "" {
@@ -205,12 +201,11 @@ func TestCheckoutTag_Checkout(t *testing.T) {
 func TestCheckoutCommit_Checkout(t *testing.T) {
 	g := NewWithT(t)
 
-	repo, err := initBareRepo()
+	repo, err := initBareRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer repo.Free()
-	defer os.RemoveAll(filepath.Join(repo.Path(), ".."))
 
 	c, err := commitFile(repo, "commit", "init", time.Now())
 	if err != nil {
@@ -223,11 +218,7 @@ func TestCheckoutCommit_Checkout(t *testing.T) {
 	commit := CheckoutCommit{
 		Commit: c.String(),
 	}
-	tmpDir, err := os.MkdirTemp("", "git2go")
+	tmpDir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
 
 	cc, err := commit.Checkout(context.TODO(), tmpDir, repo.Path(), nil)
 	g.Expect(err).ToNot(HaveOccurred())
@@ -239,11 +230,7 @@ func TestCheckoutCommit_Checkout(t *testing.T) {
 	commit = CheckoutCommit{
 		Commit: "4dc3185c5fc94eb75048376edeb44571cece25f4",
 	}
-	tmpDir2, err := os.MkdirTemp("", "git2go")
+	tmpDir2 := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir2)
 
 	cc, err = commit.Checkout(context.TODO(), tmpDir2, repo.Path(), nil)
 	g.Expect(err).To(HaveOccurred())
@@ -313,12 +300,11 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 		},
 	}
 
-	repo, err := initBareRepo()
+	repo, err := initBareRepo(t)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer repo.Free()
-	defer os.RemoveAll(filepath.Join(repo.Path(), ".."))
 
 	refs := make(map[string]string, len(tags))
 	for _, tt := range tags {
@@ -349,8 +335,7 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 			semVer := CheckoutSemVer{
 				SemVer: tt.constraint,
 			}
-			tmpDir, _ := os.MkdirTemp("", "test")
+			tmpDir := t.TempDir()
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := semVer.Checkout(context.TODO(), tmpDir, repo.Path(), nil)
 			if tt.expectErr != nil {
@@ -367,14 +352,10 @@ func TestCheckoutTagSemVer_Checkout(t *testing.T) {
 	}
 }
 
-func initBareRepo() (*git2go.Repository, error) {
+func initBareRepo(t *testing.T) (*git2go.Repository, error) {
-	tmpDir, err := os.MkdirTemp("", "git2go-")
+	tmpDir := t.TempDir()
-	if err != nil {
-		return nil, err
-	}
 	repo, err := git2go.InitRepository(tmpDir, false)
 	if err != nil {
-		_ = os.RemoveAll(tmpDir)
 		return nil, err
 	}
 	return repo, nil
@@ -514,8 +495,7 @@ func TestCheckout_ED25519(t *testing.T) {
 
 	// Prepare for checkout.
 	branchCheckoutStrat := &CheckoutBranch{Branch: git.DefaultBranch}
-	tmpDir, _ := os.MkdirTemp("", "test")
+	tmpDir := t.TempDir()
-	defer os.RemoveAll(tmpDir)
 
 	ctx, cancel := context.WithTimeout(context.TODO(), timeout)
 	defer cancel()

pkg/git/libgit2/managed/managed_test.go

@@ -258,8 +258,7 @@ func TestManagedTransport_E2E(t *testing.T) {
 	err = server.InitRepo("../testdata/git/repo", git.DefaultBranch, repoPath)
 	g.Expect(err).ToNot(HaveOccurred())
 
-	tmpDir, _ := os.MkdirTemp("", "test")
+	tmpDir := t.TempDir()
-	defer os.RemoveAll(tmpDir)
 
 	// Test HTTP transport
 
@@ -285,8 +284,7 @@ func TestManagedTransport_E2E(t *testing.T) {
 	g.Expect(err).ToNot(HaveOccurred())
 	repo.Free()
 
-	tmpDir2, _ := os.MkdirTemp("", "test")
+	tmpDir2 := t.TempDir()
-	defer os.RemoveAll(tmpDir2)
 
 	kp, err := ssh.NewEd25519Generator().Generate()
 	g.Expect(err).ToNot(HaveOccurred())
@@ -313,8 +311,7 @@ func TestManagedTransport_E2E(t *testing.T) {
 func TestManagedTransport_HandleRedirect(t *testing.T) {
 	g := NewWithT(t)
 
-	tmpDir, _ := os.MkdirTemp("", "test")
+	tmpDir := t.TempDir()
-	defer os.RemoveAll(tmpDir)
 
 	// Force managed transport to be enabled
 	InitManagedTransport(logr.Discard())

pkg/git/strategy/proxy/strategy_proxy_test.go

@@ -264,9 +264,7 @@ func TestCheckoutStrategyForImplementation_Proxied(t *testing.T) {
 			})
 			g.Expect(err).ToNot(HaveOccurred())
 
-			tmpDir, err := os.MkdirTemp("", "test-checkout")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			// for the NO_PROXY test we dont want to wait the 30s for it to timeout/fail, so shorten the timeout
 			checkoutCtx := context.TODO()

pkg/git/strategy/strategy_test.go

@@ -180,9 +180,7 @@ func TestCheckoutStrategyForImplementation_Auth(t *testing.T) {
 			checkoutStrategy, err := CheckoutStrategyForImplementation(context.TODO(), impl, checkoutOpts)
 			g.Expect(err).ToNot(HaveOccurred())
 
-			tmpDir, err := os.MkdirTemp("", "test-checkout")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			tt.wantFunc(g, checkoutStrategy, tmpDir, repoURL, authOpts)
 		}
@@ -271,9 +269,7 @@ func TestCheckoutStrategyForImplementation_SemVerCheckout(t *testing.T) {
 	}
 
 	// Clone the repo locally.
-	cloneDir, err := os.MkdirTemp("", "test-clone")
+	cloneDir := t.TempDir()
-	g.Expect(err).ToNot(HaveOccurred())
-	defer os.RemoveAll(cloneDir)
 	repo, err := extgogit.PlainClone(cloneDir, false, &extgogit.CloneOptions{
 		URL: repoURL,
 	})
@@ -332,9 +328,7 @@ func TestCheckoutStrategyForImplementation_SemVerCheckout(t *testing.T) {
 			g.Expect(err).ToNot(HaveOccurred())
 
 			// Checkout and verify.
-			tmpDir, err := os.MkdirTemp("", "test-checkout")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			cc, err := checkoutStrategy.Checkout(context.TODO(), tmpDir, repoURL, authOpts)
 			if tt.expectErr != nil {
@@ -425,9 +419,7 @@ func TestCheckoutStrategyForImplementation_WithCtxTimeout(t *testing.T) {
 			checkoutStrategy, err := CheckoutStrategyForImplementation(context.TODO(), impl, checkoutOpts)
 			g.Expect(err).ToNot(HaveOccurred())
 
-			tmpDir, err := os.MkdirTemp("", "test-checkout")
+			tmpDir := t.TempDir()
-			g.Expect(err).ToNot(HaveOccurred())
-			defer os.RemoveAll(tmpDir)
 
 			checkoutCtx, cancel := context.WithTimeout(context.TODO(), tt.timeout)
 			defer cancel()

pkg/minio/minio_test.go

@@ -144,22 +144,18 @@ func TestBucketNotExists(t *testing.T) {
 
 func TestFGetObject(t *testing.T) {
 	ctx := context.Background()
-	tempDir, err := os.MkdirTemp("", bucketName)
+	tempDir := t.TempDir()
-	assert.NilError(t, err)
-	defer os.RemoveAll(tempDir)
 	path := filepath.Join(tempDir, sourceignore.IgnoreFile)
-	_, err = minioClient.FGetObject(ctx, bucketName, objectName, path)
+	_, err := minioClient.FGetObject(ctx, bucketName, objectName, path)
 	assert.NilError(t, err)
 }
 
 func TestFGetObjectNotExists(t *testing.T) {
 	ctx := context.Background()
-	tempDir, err := os.MkdirTemp("", bucketName)
+	tempDir := t.TempDir()
-	assert.NilError(t, err)
-	defer os.RemoveAll(tempDir)
 	badKey := "invalid.txt"
 	path := filepath.Join(tempDir, badKey)
-	_, err = minioClient.FGetObject(ctx, bucketName, badKey, path)
+	_, err := minioClient.FGetObject(ctx, bucketName, badKey, path)
 	assert.Error(t, err, "The specified key does not exist.")
 	assert.Check(t, minioClient.ObjectIsNotFound(err))
 }

pkg/sourceignore/sourceignore_test.go

@@ -197,11 +197,7 @@ func TestDefaultPatterns(t *testing.T) {
 }
 
 func TestLoadExcludePatterns(t *testing.T) {
-	tmpDir, err := os.MkdirTemp("", "sourceignore-load-")
+	tmpDir := t.TempDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tmpDir)
 	files := map[string]string{
 		".sourceignore":     "root.txt",
 		"d/.gitignore":      "ignored",
@@ -209,10 +205,10 @@ func TestLoadExcludePatterns(t *testing.T) {
 		"a/b/.sourceignore": "subdir.txt",
 	}
 	for n, c := range files {
-		if err = os.MkdirAll(filepath.Join(tmpDir, filepath.Dir(n)), 0o750); err != nil {
+		if err := os.MkdirAll(filepath.Join(tmpDir, filepath.Dir(n)), 0o750); err != nil {
 			t.Fatal(err)
 		}
-		if err = os.WriteFile(filepath.Join(tmpDir, n), []byte(c), 0o640); err != nil {
+		if err := os.WriteFile(filepath.Join(tmpDir, n), []byte(c), 0o640); err != nil {
 			t.Fatal(err)
 		}
 	}