system/dispatcher: wrap syscall helper functions

This allows tests to stub all kernel behaviour, like in the container package.

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

system/acl.go

@@ -31,22 +31,22 @@ type ACLUpdateOp struct {
 func (a *ACLUpdateOp) Type() Enablement { return a.et }
 
 func (a *ACLUpdateOp) apply(sys *I) error {
-	msg.Verbose("applying ACL", a)
+	sys.verbose("applying ACL", a)
-	return newOpError("acl", acl.Update(a.path, sys.uid, a.perms...), false)
+	return newOpError("acl", sys.aclUpdate(a.path, sys.uid, a.perms...), false)
 }
 
 func (a *ACLUpdateOp) revert(sys *I, ec *Criteria) error {
 	if ec.hasType(a.Type()) {
-		msg.Verbose("stripping ACL", a)
+		sys.verbose("stripping ACL", a)
-		err := acl.Update(a.path, sys.uid)
+		err := sys.aclUpdate(a.path, sys.uid)
 		if errors.Is(err, os.ErrNotExist) {
 			// the ACL is effectively stripped if the file no longer exists
-			msg.Verbosef("target of ACL %s no longer exists", a)
+			sys.verbosef("target of ACL %s no longer exists", a)
 			err = nil
 		}
 		return newOpError("acl", err, true)
 	} else {
-		msg.Verbose("skipping ACL", a)
+		sys.verbose("skipping ACL", a)
 		return nil
 	}
 }

system/acl_test.go

@@ -1,91 +1,183 @@
 package system
 
 import (
+	"os"
+	"syscall"
 	"testing"
 
-	"hakurei.app/container"
+	"hakurei.app/container/stub"
 	"hakurei.app/system/acl"
 )
 
-func TestUpdatePerm(t *testing.T) {
+func TestACLUpdateOp(t *testing.T) {
-	testCases := []struct {
+	checkOpBehaviour(t, []opBehaviourTestCase{
-		path  string
+		{"apply aclUpdate", 0xdeadbeef, 0xff,
-		perms []acl.Perm
+			&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}, []stub.Call{
-	}{
+				call("verbose", stub.ExpectArgs{[]any{"applying ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-		{"/run/user/1971/hakurei", []acl.Perm{acl.Execute}},
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, []acl.Perm{acl.Read, acl.Write, acl.Execute}}, nil, stub.UniqueError(1)),
-		{"/tmp/hakurei.1971/tmpdir/150", []acl.Perm{acl.Read, acl.Write, acl.Execute}},
+			}, &OpError{Op: "acl", Err: stub.UniqueError(1)}, nil, nil},
-	}
 
-	for _, tc := range testCases {
+		{"revert aclUpdate", 0xdeadbeef, 0xff,
-		t.Run(tc.path+permSubTestSuffix(tc.perms), func(t *testing.T) {
+			&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}, []stub.Call{
-			sys := New(t.Context(), 150)
+				call("verbose", stub.ExpectArgs{[]any{"applying ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-			sys.UpdatePerm(tc.path, tc.perms...)
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, []acl.Perm{acl.Read, acl.Write, acl.Execute}}, nil, nil),
-			(&tcOp{Process, tc.path}).test(t, sys.ops, []Op{&ACLUpdateOp{Process, tc.path, tc.perms}}, "UpdatePerm")
+			}, nil, []stub.Call{
-		})
+				call("verbose", stub.ExpectArgs{[]any{"stripping ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-	}
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, ([]acl.Perm)(nil)}, nil, stub.UniqueError(0)),
-}
+			}, &OpError{Op: "acl", Err: stub.UniqueError(0), Revert: true}},
-
+
-func TestUpdatePermType(t *testing.T) {
+		{"success revert skip", 0xdeadbeef, Process,
-	testCases := []struct {
+			&ACLUpdateOp{User, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}, []stub.Call{
-		perms []acl.Perm
+				call("verbose", stub.ExpectArgs{[]any{"applying ACL", &ACLUpdateOp{User, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-		tcOp
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, []acl.Perm{acl.Read, acl.Write, acl.Execute}}, nil, nil),
-	}{
+			}, nil, []stub.Call{
-		{[]acl.Perm{acl.Execute}, tcOp{User, "/tmp/hakurei.1971/tmpdir"}},
+				call("verbose", stub.ExpectArgs{[]any{"skipping ACL", &ACLUpdateOp{User, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-		{[]acl.Perm{acl.Read, acl.Write, acl.Execute}, tcOp{User, "/tmp/hakurei.1971/tmpdir/150"}},
+			}, nil},
-		{[]acl.Perm{acl.Execute}, tcOp{Process, "/run/user/1971/hakurei/fcb8a12f7c482d183ade8288c3de78b5"}},
+
-		{[]acl.Perm{acl.Read}, tcOp{Process, "/tmp/hakurei.1971/fcb8a12f7c482d183ade8288c3de78b5/passwd"}},
+		{"success revert aclUpdate ENOENT", 0xdeadbeef, 0xff,
-		{[]acl.Perm{acl.Read}, tcOp{Process, "/tmp/hakurei.1971/fcb8a12f7c482d183ade8288c3de78b5/group"}},
+			&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}, []stub.Call{
-		{[]acl.Perm{acl.Read, acl.Write, acl.Execute}, tcOp{EWayland, "/run/user/1971/wayland-0"}},
+				call("verbose", stub.ExpectArgs{[]any{"applying ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-	}
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, []acl.Perm{acl.Read, acl.Write, acl.Execute}}, nil, nil),
-
+			}, nil, []stub.Call{
-	for _, tc := range testCases {
+				call("verbose", stub.ExpectArgs{[]any{"stripping ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-		t.Run(tc.path+"_"+TypeString(tc.et)+permSubTestSuffix(tc.perms), func(t *testing.T) {
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, ([]acl.Perm)(nil)}, nil, &os.PathError{Op: "acl_get_file", Path: "/proc/nonexistent", Err: syscall.ENOENT}),
-			sys := New(t.Context(), 150)
+				call("verbosef", stub.ExpectArgs{"target of ACL %s no longer exists", []any{&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-			sys.UpdatePermType(tc.et, tc.path, tc.perms...)
+			}, nil},
-			tc.test(t, sys.ops, []Op{&ACLUpdateOp{tc.et, tc.path, tc.perms}}, "UpdatePermType")
+
-		})
+		{"success", 0xdeadbeef, 0xff,
-	}
+			&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}, []stub.Call{
-}
+				call("verbose", stub.ExpectArgs{[]any{"applying ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, []acl.Perm{acl.Read, acl.Write, acl.Execute}}, nil, nil),
-func TestACLString(t *testing.T) {
+			}, nil, []stub.Call{
-	testCases := []struct {
+				call("verbose", stub.ExpectArgs{[]any{"stripping ACL", &ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{acl.Read, acl.Write, acl.Execute}}}}, nil, nil),
-		want  string
+				call("aclUpdate", stub.ExpectArgs{"/proc/nonexistent", 0xdeadbeef, ([]acl.Perm)(nil)}, nil, nil),
-		et    Enablement
+			}, nil},
-		perms []acl.Perm
+	})
-	}{
+
-		{`--- type: process path: "/proc/nonexistent"`, Process, []acl.Perm{}},
+	checkOpsBuilder(t, "UpdatePerm", []opsBuilderTestCase{
-		{`r-- type: user path: "/proc/nonexistent"`, User, []acl.Perm{acl.Read}},
+		{"simple",
-		{`-w- type: wayland path: "/proc/nonexistent"`, EWayland, []acl.Perm{acl.Write}},
+			0xdeadbeef,
-		{`--x type: x11 path: "/proc/nonexistent"`, EX11, []acl.Perm{acl.Execute}},
+			func(sys *I) {
-		{`rw- type: dbus path: "/proc/nonexistent"`, EDBus, []acl.Perm{acl.Read, acl.Write}},
+				sys.
-		{`r-x type: pulseaudio path: "/proc/nonexistent"`, EPulse, []acl.Perm{acl.Read, acl.Execute}},
+					UpdatePerm("/run/user/1971/hakurei", acl.Execute).
-		{`rwx type: user path: "/proc/nonexistent"`, User, []acl.Perm{acl.Read, acl.Write, acl.Execute}},
+					UpdatePerm("/tmp/hakurei.0/tmpdir/150", acl.Read, acl.Write, acl.Execute)
-		{`rwx type: process path: "/proc/nonexistent"`, Process, []acl.Perm{acl.Read, acl.Write, acl.Write, acl.Execute}},
+			}, []Op{
-	}
+				&ACLUpdateOp{Process, "/run/user/1971/hakurei", []acl.Perm{acl.Execute}},
-
+				&ACLUpdateOp{Process, "/tmp/hakurei.0/tmpdir/150", []acl.Perm{acl.Read, acl.Write, acl.Execute}},
-	for _, tc := range testCases {
+			}, stub.Expect{}},
-		t.Run(tc.want, func(t *testing.T) {
+	})
-			a := &ACLUpdateOp{et: tc.et, perms: tc.perms, path: container.Nonexistent}
+	checkOpsBuilder(t, "UpdatePermType", []opsBuilderTestCase{
-			if got := a.String(); got != tc.want {
+		{"tmpdirp", 0xdeadbeef, func(sys *I) {
-				t.Errorf("String() = %v, want %v",
+			sys.UpdatePermType(User, "/tmp/hakurei.0/tmpdir", acl.Execute)
-					got, tc.want)
+		}, []Op{
-			}
+			&ACLUpdateOp{User, "/tmp/hakurei.0/tmpdir", []acl.Perm{acl.Execute}},
-		})
+		}, stub.Expect{}},
-	}
+
-}
+		{"tmpdir", 0xdeadbeef, func(sys *I) {
-
+			sys.UpdatePermType(User, "/tmp/hakurei.0/tmpdir/150", acl.Read, acl.Write, acl.Execute)
-func permSubTestSuffix(perms []acl.Perm) (suffix string) {
+		}, []Op{
-	for _, perm := range perms {
+			&ACLUpdateOp{User, "/tmp/hakurei.0/tmpdir/150", []acl.Perm{acl.Read, acl.Write, acl.Execute}},
-		switch perm {
+		}, stub.Expect{}},
-		case acl.Read:
+
-			suffix += "_read"
+		{"share", 0xdeadbeef, func(sys *I) {
-		case acl.Write:
+			sys.UpdatePermType(Process, "/run/user/1971/hakurei/fcb8a12f7c482d183ade8288c3de78b5", acl.Execute)
-			suffix += "_write"
+		}, []Op{
-		case acl.Execute:
+			&ACLUpdateOp{Process, "/run/user/1971/hakurei/fcb8a12f7c482d183ade8288c3de78b5", []acl.Perm{acl.Execute}},
-			suffix += "_execute"
+		}, stub.Expect{}},
-		default:
+
-			panic("unreachable")
+		{"passwd", 0xdeadbeef, func(sys *I) {
-		}
+			sys.
-	}
+				UpdatePermType(Process, "/tmp/hakurei.0/fcb8a12f7c482d183ade8288c3de78b5/passwd", acl.Read).
-	return
+				UpdatePermType(Process, "/tmp/hakurei.0/fcb8a12f7c482d183ade8288c3de78b5/group", acl.Read)
+		}, []Op{
+			&ACLUpdateOp{Process, "/tmp/hakurei.0/fcb8a12f7c482d183ade8288c3de78b5/passwd", []acl.Perm{acl.Read}},
+			&ACLUpdateOp{Process, "/tmp/hakurei.0/fcb8a12f7c482d183ade8288c3de78b5/group", []acl.Perm{acl.Read}},
+		}, stub.Expect{}},
+
+		{"wayland", 0xdeadbeef, func(sys *I) {
+			sys.UpdatePermType(EWayland, "/run/user/1971/wayland-0", acl.Read, acl.Write, acl.Execute)
+		}, []Op{
+			&ACLUpdateOp{EWayland, "/run/user/1971/wayland-0", []acl.Perm{acl.Read, acl.Write, acl.Execute}},
+		}, stub.Expect{}},
+	})
+
+	checkOpIs(t, []opIsTestCase{
+		{"nil", (*ACLUpdateOp)(nil), (*ACLUpdateOp)(nil), false},
+		{"zero", new(ACLUpdateOp), new(ACLUpdateOp), true},
+
+		{"et differs",
+			&ACLUpdateOp{
+				EWayland, "/run/user/1971/wayland-0",
+				[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+			}, &ACLUpdateOp{
+				EX11, "/run/user/1971/wayland-0",
+				[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+			}, false},
+
+		{"path differs", &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-0",
+			[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+		}, &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-1",
+			[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+		}, false},
+
+		{"perms differs", &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-0",
+			[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+		}, &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-0",
+			[]acl.Perm{acl.Read, acl.Write},
+		}, false},
+
+		{"equals", &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-0",
+			[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+		}, &ACLUpdateOp{
+			EWayland, "/run/user/1971/wayland-0",
+			[]acl.Perm{acl.Read, acl.Write, acl.Execute},
+		}, true},
+	})
+
+	checkOpMeta(t, []opMetaTestCase{
+		{"clear",
+			&ACLUpdateOp{Process, "/proc/nonexistent", []acl.Perm{}},
+			Process, "/proc/nonexistent",
+			`--- type: process path: "/proc/nonexistent"`},
+
+		{"read",
+			&ACLUpdateOp{User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/0", []acl.Perm{acl.Read}},
+			User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/0",
+			`r-- type: user path: "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/0"`},
+
+		{"write",
+			&ACLUpdateOp{User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/1", []acl.Perm{acl.Write}},
+			User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/1",
+			`-w- type: user path: "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/1"`},
+
+		{"execute",
+			&ACLUpdateOp{User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/2", []acl.Perm{acl.Execute}},
+			User, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/2",
+			`--x type: user path: "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/2"`},
+
+		{"wayland",
+			&ACLUpdateOp{EWayland, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/wayland", []acl.Perm{acl.Read, acl.Write}},
+			EWayland, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/wayland",
+			`rw- type: wayland path: "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/wayland"`},
+
+		{"x11",
+			&ACLUpdateOp{EX11, "/tmp/.X11-unix/X0", []acl.Perm{acl.Read, acl.Execute}},
+			EX11, "/tmp/.X11-unix/X0",
+			`r-x type: x11 path: "/tmp/.X11-unix/X0"`},
+
+		{"dbus",
+			&ACLUpdateOp{EDBus, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/bus", []acl.Perm{acl.Write, acl.Execute}},
+			EDBus, "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/bus",
+			`-wx type: dbus path: "/tmp/hakurei.0/27d81d567f8fae7f33278eec45da9446/bus"`},
+
+		{"pulseaudio",
+			&ACLUpdateOp{EPulse, "/run/user/1971/hakurei/27d81d567f8fae7f33278eec45da9446/pulse", []acl.Perm{acl.Read, acl.Write, acl.Execute}},
+			EPulse, "/run/user/1971/hakurei/27d81d567f8fae7f33278eec45da9446/pulse",
+			`rwx type: pulseaudio path: "/run/user/1971/hakurei/27d81d567f8fae7f33278eec45da9446/pulse"`},
+	})
 }

system/dispatcher.go

@@ -0,0 +1,30 @@
+package system
+
+import "hakurei.app/system/acl"
+
+// syscallDispatcher provides methods that make state-dependent system calls as part of their behaviour.
+// syscallDispatcher is embedded in [I], so all methods must be unexported.
+type syscallDispatcher interface {
+	// new starts a goroutine with a new instance of syscallDispatcher.
+	// A syscallDispatcher must never be used in any goroutine other than the one owning it,
+	// just synchronising access is not enough, as this is for test instrumentation.
+	new(f func(k syscallDispatcher))
+
+	// aclUpdate provides [acl.Update].
+	aclUpdate(name string, uid int, perms ...acl.Perm) error
+
+	verbose(v ...any)
+	verbosef(format string, v ...any)
+}
+
+// direct implements syscallDispatcher on the current kernel.
+type direct struct{}
+
+func (k direct) new(f func(k syscallDispatcher)) { go f(k) }
+
+func (k direct) aclUpdate(name string, uid int, perms ...acl.Perm) error {
+	return acl.Update(name, uid, perms...)
+}
+
+func (direct) verbose(v ...any)                 { msg.Verbose(v...) }
+func (direct) verbosef(format string, v ...any) { msg.Verbosef(format, v...) }

system/dispatcher_test.go

@@ -0,0 +1,215 @@
+package system
+
+import (
+	"reflect"
+	"slices"
+	"testing"
+
+	"hakurei.app/container/stub"
+	"hakurei.app/system/acl"
+)
+
+// call initialises a [stub.Call].
+// This keeps composites analysis happy without making the test cases too bloated.
+func call(name string, args stub.ExpectArgs, ret any, err error) stub.Call {
+	return stub.Call{Name: name, Args: args, Ret: ret, Err: err}
+}
+
+type opBehaviourTestCase struct {
+	name string
+	uid  int
+	ec   Enablement
+	op   Op
+
+	apply        []stub.Call
+	wantErrApply error
+
+	revert        []stub.Call
+	wantErrRevert error
+}
+
+func checkOpBehaviour(t *testing.T, testCases []opBehaviourTestCase) {
+	t.Helper()
+
+	t.Run("behaviour", func(t *testing.T) {
+		t.Helper()
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Helper()
+
+				var ec *Criteria
+				if tc.ec != 0xff {
+					ec = (*Criteria)(&tc.ec)
+				}
+
+				defer stub.HandleExit()
+				sys, s := InternalNew(t, stub.Expect{Calls: slices.Concat(tc.apply, []stub.Call{{Name: stub.CallSeparator}}, tc.revert)}, tc.uid)
+				errApply := tc.op.apply(sys)
+				s.Expects(stub.CallSeparator)
+				if !reflect.DeepEqual(errApply, tc.wantErrApply) {
+					t.Errorf("apply: error = %v, want %v", errApply, tc.wantErrApply)
+				}
+				if errApply != nil {
+					goto out
+				}
+
+				if err := tc.op.revert(sys, ec); !reflect.DeepEqual(err, tc.wantErrRevert) {
+					t.Errorf("revert: error = %v, want %v", err, tc.wantErrRevert)
+				}
+
+			out:
+				s.VisitIncomplete(func(s *stub.Stub[syscallDispatcher]) {
+					count := s.Pos() - 1 // separator
+					if count < len(tc.apply) {
+						t.Errorf("apply: %d calls, want %d", count, len(tc.apply))
+					} else {
+						t.Errorf("revert: %d calls, want %d", count-len(tc.apply), len(tc.revert))
+					}
+				})
+			})
+		}
+	})
+}
+
+type opsBuilderTestCase struct {
+	name string
+	uid  int
+	f    func(sys *I)
+	want []Op
+	exp  stub.Expect
+}
+
+func checkOpsBuilder(t *testing.T, fname string, testCases []opsBuilderTestCase) {
+	t.Helper()
+
+	t.Run("build", func(t *testing.T) {
+		t.Helper()
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Helper()
+
+				defer stub.HandleExit()
+				sys, s := InternalNew(t, tc.exp, tc.uid)
+				tc.f(sys)
+				s.VisitIncomplete(func(s *stub.Stub[syscallDispatcher]) {
+					t.Helper()
+
+					t.Errorf("%s: %d calls, want %d", fname, s.Pos(), s.Len())
+				})
+				if !slices.EqualFunc(sys.ops, tc.want, func(op Op, v Op) bool { return op.Is(v) }) {
+					t.Errorf("ops: %#v, want %#v", sys.ops, tc.want)
+				}
+			})
+		}
+	})
+}
+
+type opIsTestCase struct {
+	name  string
+	op, v Op
+	want  bool
+}
+
+func checkOpIs(t *testing.T, testCases []opIsTestCase) {
+	t.Helper()
+
+	t.Run("is", func(t *testing.T) {
+		t.Helper()
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Helper()
+
+				if got := tc.op.Is(tc.v); got != tc.want {
+					t.Errorf("Is: %v, want %v", got, tc.want)
+				}
+			})
+		}
+	})
+}
+
+type opMetaTestCase struct {
+	name string
+	op   Op
+
+	wantType   Enablement
+	wantPath   string
+	wantString string
+}
+
+func checkOpMeta(t *testing.T, testCases []opMetaTestCase) {
+	t.Helper()
+
+	t.Run("meta", func(t *testing.T) {
+		t.Helper()
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Helper()
+
+				t.Run("type", func(t *testing.T) {
+					t.Helper()
+
+					if got := tc.op.Type(); got != tc.wantType {
+						t.Errorf("Type: %q, want %q", got, tc.wantType)
+					}
+				})
+
+				t.Run("path", func(t *testing.T) {
+					t.Helper()
+
+					if got := tc.op.Path(); got != tc.wantPath {
+						t.Errorf("Path: %q, want %q", got, tc.wantPath)
+					}
+				})
+
+				t.Run("string", func(t *testing.T) {
+					t.Helper()
+
+					if got := tc.op.String(); got != tc.wantString {
+						t.Errorf("String: %s, want %s", got, tc.wantString)
+					}
+				})
+			})
+		}
+	})
+}
+
+// InternalNew initialises [I] with a stub syscallDispatcher.
+func InternalNew(t *testing.T, want stub.Expect, uid int) (*I, *stub.Stub[syscallDispatcher]) {
+	k := stub.New(t, func(s *stub.Stub[syscallDispatcher]) syscallDispatcher { return &kstub{s} }, want)
+	sys := New(t.Context(), uid)
+	sys.syscallDispatcher = &kstub{k}
+	return sys, k
+}
+
+type kstub struct{ *stub.Stub[syscallDispatcher] }
+
+func (k *kstub) new(f func(k syscallDispatcher)) { k.Helper(); k.New(f) }
+
+func (k *kstub) aclUpdate(name string, uid int, perms ...acl.Perm) error {
+	k.Helper()
+	return k.Expects("aclUpdate").Error(
+		stub.CheckArg(k.Stub, "name", name, 0),
+		stub.CheckArg(k.Stub, "uid", uid, 1),
+		stub.CheckArgReflect(k.Stub, "perms", perms, 2))
+}
+
+func (k *kstub) verbose(v ...any) {
+	k.Helper()
+	if k.Expects("verbose").Error(
+		stub.CheckArgReflect(k.Stub, "v", v, 0)) != nil {
+		k.FailNow()
+	}
+}
+
+func (k *kstub) verbosef(format string, v ...any) {
+	k.Helper()
+	if k.Expects("verbosef").Error(
+		stub.CheckArg(k.Stub, "format", format, 0),
+		stub.CheckArgReflect(k.Stub, "v", v, 1)) != nil {
+		k.FailNow()
+	}
+}

system/system.go

@@ -70,7 +70,7 @@ func New(ctx context.Context, uid int) (sys *I) {
 	if ctx == nil || uid < 0 {
 		panic("invalid call to New")
 	}
-	return &I{ctx: ctx, uid: uid}
+	return &I{ctx: ctx, uid: uid, syscallDispatcher: direct{}}
 }
 
 // An I provides deferred operating system interaction. [I] must not be copied.
@@ -86,6 +86,8 @@ type I struct {
 	committed bool
 	// the behaviour of Revert is only defined for up to one call
 	reverted bool
+
+	syscallDispatcher
 }
 
 func (sys *I) UID() int { return sys.uid }