Migrate TestRunDevice test

Signed-off-by: apostasie <spam_blackhole@farcloser.world>

Author: apostasie

cmd/nerdctl/container/container_run_cgroup_linux_test.go

@@ -22,16 +22,18 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"testing"
 
-	"github.com/moby/sys/userns"
 	"gotest.tools/v3/assert"
 
 	"github.com/containerd/cgroups/v3"
 	containerd "github.com/containerd/containerd/v2/client"
 	"github.com/containerd/continuity/testutil/loopback"
+	"github.com/containerd/nerdctl/mod/tigron/expect"
 	"github.com/containerd/nerdctl/mod/tigron/require"
+	"github.com/containerd/nerdctl/mod/tigron/test"
 
 	"github.com/containerd/nerdctl/v2/pkg/cmd/container"
 	"github.com/containerd/nerdctl/v2/pkg/idutil/containerwalker"
@@ -224,9 +226,9 @@ func TestIssue3781(t *testing.T) {
 }
 
 func TestRunDevice(t *testing.T) {
-	if os.Geteuid() != 0 || userns.RunningInUserNS() {
-		t.Skip("test requires the root in the initial user namespace")
-	}
+	testCase := nerdtest.Setup()
+
+	testCase.Require = nerdtest.Rootful
 
 	if unameR := infoutil.UnameR(); strings.Contains(unameR, ".el8") {
 		t.Logf("Assuming to be running on EL8 (kernel release %q)", unameR)
@@ -238,39 +240,93 @@ func TestRunDevice(t *testing.T) {
 
 	const n = 3
 	lo := make([]*loopback.Loopback, n)
-	loContent := make([]string, n)
 
-	for i := 0; i < n; i++ {
-		var err error
-		lo[i], err = loopback.New(4096)
-		assert.NilError(t, err)
-		t.Logf("lo[%d] = %+v", i, lo[i])
-		defer lo[i].Close()
-		loContent[i] = fmt.Sprintf("lo%d-content", i)
-		assert.NilError(t, os.WriteFile(lo[i].Device, []byte(loContent[i]), 0700))
+	testCase.Setup = func(data test.Data, helpers test.Helpers) {
+
+		for i := 0; i < n; i++ {
+			var err error
+			lo[i], err = loopback.New(4096)
+			assert.NilError(t, err)
+			t.Logf("lo[%d] = %+v", i, lo[i])
+			loContent := fmt.Sprintf("lo%d-content", i)
+			assert.NilError(t, os.WriteFile(lo[i].Device, []byte(loContent), 0o700))
+			data.Set("loContent"+strconv.Itoa(i), loContent)
+		}
+
+		// lo0 is readable but not writable.
+		// lo1 is readable and writable
+		// lo2 is not accessible.
+		helpers.Ensure("run",
+			"-d",
+			"--name", data.Identifier(),
+			"--device", lo[0].Device+":r",
+			"--device", lo[1].Device,
+			testutil.AlpineImage, "sleep", nerdtest.Infinity)
+		data.Set("id", data.Identifier())
+	}
+
+	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
+		for i := 0; i < n; i++ {
+			if lo[i] != nil {
+				_ = lo[i].Close()
+			}
+		}
+		helpers.Anyhow("rm", "-f", data.Identifier())
 	}
 
-	base := testutil.NewBase(t)
-	containerName := testutil.Identifier(t)
-	defer base.Cmd("rm", "-f", containerName).AssertOK()
-	// lo0 is readable but not writable.
-	// lo1 is readable and writable
-	// lo2 is not accessible.
-	base.Cmd("run",
-		"-d",
-		"--name", containerName,
-		"--device", lo[0].Device+":r",
-		"--device", lo[1].Device,
-		testutil.AlpineImage, "sleep", nerdtest.Infinity).Run()
-
-	base.Cmd("exec", containerName, "cat", lo[0].Device).AssertOutContains(loContent[0])
-	base.Cmd("exec", containerName, "cat", lo[1].Device).AssertOutContains(loContent[1])
-	base.Cmd("exec", containerName, "cat", lo[2].Device).AssertFail()
-	base.Cmd("exec", containerName, "sh", "-ec", "echo -n \"overwritten-lo0-content\">"+lo[0].Device).AssertFail()
-	base.Cmd("exec", containerName, "sh", "-ec", "echo -n \"overwritten-lo1-content\">"+lo[1].Device).AssertOK()
-	lo1Read, err := os.ReadFile(lo[1].Device)
-	assert.NilError(t, err)
-	assert.Equal(t, string(bytes.Trim(lo1Read, "\x00")), "overwritten-lo1-content")
+	testCase.SubTests = []*test.Case{
+		{
+			Description: "can read lo0",
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Get("id"), "cat", lo[0].Device)
+			},
+			Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
+				return &test.Expected{
+					Output: expect.Contains(data.Get("locontent0")),
+				}
+			},
+		},
+		{
+			Description: "cannot write lo0",
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Get("id"), "sh", "-ec", "echo -n \"overwritten-lo1-content\">"+lo[0].Device)
+			},
+			Expected: test.Expects(expect.ExitCodeGenericFail, nil, nil),
+		},
+		{
+			Description: "cannot read lo2",
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Get("id"), "cat", lo[2].Device)
+			},
+			Expected: test.Expects(expect.ExitCodeGenericFail, nil, nil),
+		},
+		{
+			Description: "can read lo1",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Get("id"), "cat", lo[1].Device)
+			},
+			Expected: func(data test.Data, helpers test.Helpers) *test.Expected {
+				return &test.Expected{
+					Output: expect.Contains(data.Get("locontent1")),
+				}
+			},
+		},
+		{
+			Description: "can write lo1 and read back updated value",
+			NoParallel:  true,
+			Command: func(data test.Data, helpers test.Helpers) test.TestableCommand {
+				return helpers.Command("exec", data.Get("id"), "sh", "-ec", "echo -n \"overwritten-lo1-content\">"+lo[1].Device)
+			},
+			Expected: test.Expects(expect.ExitCodeSuccess, nil, func(stdout string, info string, t *testing.T) {
+				lo1Read, err := os.ReadFile(lo[1].Device)
+				assert.NilError(t, err)
+				assert.Equal(t, string(bytes.Trim(lo1Read, "\x00")), "overwritten-lo1-content")
+			}),
+		},
+	}
+
+	testCase.Run(t)
 }
 
 func TestParseDevice(t *testing.T) {