internal/acl: make tests parallel

This increases testing performance.

Signed-off-by: Ophestra <cat@gensokyo.uk>

1 files changed, 46 insertions, 52 deletions

diff --git a/internal/acl/acl_test.go b/internal/acl/acl_test.go
index 6e84e832..14f0ca18 100644
--- a/internal/acl/acl_test.go
+++ b/internal/acl/acl_test.go
@@ -18,13 +18,23 @@ import (
 	"hakurei.app/internal/info"
 )
 
-const testFileName = "acl.test"
-
 var (
 	uid  = os.Geteuid()
 	cred = int32(uid)
 )
 
+// testFile returns the pathname of a newly created test file.
+func testFile(t *testing.T) string {
+	name := filepath.Join(t.TempDir(), "f")
+	f, err := os.Create(name)
+	if err != nil {
+		t.Fatal(err)
+	} else if err = f.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return name
+}
+
 func TestUpdate(t *testing.T) {
 	if info.CanDegrade {
 		name := filepath.Join(t.TempDir(), "check-degrade")
@@ -36,82 +46,63 @@ func TestUpdate(t *testing.T) {
 		}
 	}
 
-	testFilePath := filepath.Join(t.TempDir(), testFileName)
+	t.Parallel()
 
-	if f, err := os.Create(testFilePath); err != nil {
-		t.Fatalf("Create: error = %v", err)
-	} else {
-		if err = f.Close(); err != nil {
-			t.Fatalf("Close: error = %v", err)
-		}
+	pathname := testFile(t)
+	cur := getfacl(t, pathname)
+	if len(cur) != 3 {
+		t.Fatalf("unexpected test file acl length %d", len(cur))
 	}
-	defer func() {
-		if err := os.Remove(testFilePath); err != nil {
-			t.Fatalf("Remove: error = %v", err)
-		}
-	}()
-
-	cur := getfacl(t, testFilePath)
-
-	t.Run("default entry count", func(t *testing.T) {
-		if len(cur) != 3 {
-			t.Fatalf("unexpected test file acl length %d", len(cur))
-		}
-	})
 
-	t.Run("default clear mask", func(t *testing.T) {
-		if err := acl.Update(testFilePath, uid, 0); err != nil {
-			t.Fatalf("Update: error = %v", err)
-		}
-		if cur = getfacl(t, testFilePath); len(cur) != 4 {
-			t.Fatalf("Update: %v", cur)
-		}
-	})
+	if err := acl.Update(pathname, uid, 0); err != nil {
+		t.Fatalf("(clear) Update: error = %v", err)
+	}
+	if cur = getfacl(t, pathname); len(cur) != 4 {
+		t.Fatalf("(clear) Update: %v", cur)
+	}
 
-	t.Run("default clear consistency", func(t *testing.T) {
-		if err := acl.Update(testFilePath, uid, 0); err != nil {
-			t.Fatalf("Update: error = %v", err)
-		}
-		if val := getfacl(t, testFilePath); !reflect.DeepEqual(val, cur) {
-			t.Fatalf("Update: %v, want %v", val, cur)
-		}
-	})
+	if err := acl.Update(pathname, uid, 0); err != nil {
+		t.Fatalf("(clear*) Update: error = %v", err)
+	}
+	if val := getfacl(t, pathname); !reflect.DeepEqual(val, cur) {
+		t.Fatalf("(clear*) Update: %v, want %v", val, cur)
+	}
 
-	testUpdate(t, testFilePath, "r--", "", cur, acl.Read, true)
-	testUpdate(t, testFilePath, "-w-", "", cur, acl.Write, true)
-	testUpdate(t, testFilePath, "--x", "", cur, acl.Execute, true)
+	testUpdate(t, "r--", "", cur, acl.Read, true)
+	testUpdate(t, "-w-", "", cur, acl.Write, true)
+	testUpdate(t, "--x", "", cur, acl.Execute, true)
 
 	testUpdate(
-		t, testFilePath, "-wx", "", cur,
+		t, "-wx", "", cur,
 		acl.Write|acl.Execute,
 		true,
 	)
 	testUpdate(
-		t, testFilePath, "r-x", "", cur,
+		t, "r-x", "", cur,
 		acl.Read|acl.Execute,
 		true,
 	)
 	testUpdate(
-		t, testFilePath, "rw-", "", cur,
+		t, "rw-", "", cur,
 		acl.Read|acl.Write,
 		true,
 	)
 	testUpdate(
-		t, testFilePath, "rwx", "", cur,
+		t, "rwx", "", cur,
 		acl.Read|acl.Write|acl.Execute,
 		true,
 	)
 
 	for i := range 16 {
 		testUpdate(
-			t, testFilePath, "r-x", " "+strconv.Itoa(i), cur,
+			t, "r-x", " "+strconv.Itoa(i), cur,
 			acl.Read|acl.Execute,
 			false,
 		)
 	}
 
 	testUpdate(
-		t, testFilePath, "rwx", " cleanup", cur,
+		t, "rwx", " cleanup", cur,
 		acl.Read|acl.Write|acl.Execute,
 		true,
 	)
@@ -119,27 +110,30 @@ func TestUpdate(t *testing.T) {
 
 func testUpdate(
 	t *testing.T,
-	testFilePath, name, suffix string,
+	name, suffix string,
 	cur []*getFACLResp,
 	perms acl.Perm,
 	cleanup bool,
 ) {
 	t.Run(name+suffix, func(t *testing.T) {
+		t.Parallel()
+
+		pathname := testFile(t)
 		if cleanup {
 			t.Cleanup(func() {
-				if err := acl.Update(testFilePath, uid, 0); err != nil {
+				if err := acl.Update(pathname, uid, 0); err != nil {
 					t.Fatalf("Update: error = %v", err)
 				}
-				if v := getfacl(t, testFilePath); !reflect.DeepEqual(v, cur) {
+				if v := getfacl(t, pathname); !reflect.DeepEqual(v, cur) {
 					t.Fatalf("Update: %v, want %v", v, cur)
 				}
 			})
 		}
 
-		if err := acl.Update(testFilePath, uid, perms); err != nil {
+		if err := acl.Update(pathname, uid, perms); err != nil {
 			t.Fatalf("Update: error = %v", err)
 		}
-		r := respByCred(getfacl(t, testFilePath), fAclTypeUser, cred)
+		r := respByCred(getfacl(t, pathname), fAclTypeUser, cred)
 		if r == nil {
 			t.Fatalf("Update did not add an ACL entry")
 		}