diff --git a/cmd/nerdctl/builder/builder_build_oci_layout_test.go b/cmd/nerdctl/builder/builder_build_oci_layout_test.go index 93cc4152284..758675e85a1 100644 --- a/cmd/nerdctl/builder/builder_build_oci_layout_test.go +++ b/cmd/nerdctl/builder/builder_build_oci_layout_test.go @@ -18,13 +18,13 @@ package builder import ( "fmt" - "os" "path/filepath" "strings" "testing" "gotest.tools/v3/assert" + "github.com/containerd/nerdctl/mod/tigron/expect" "github.com/containerd/nerdctl/mod/tigron/require" "github.com/containerd/nerdctl/mod/tigron/test" @@ -44,17 +44,17 @@ func TestBuildContextWithOCILayout(t *testing.T) { ), Cleanup: func(data test.Data, helpers test.Helpers) { if nerdtest.IsDocker() { - helpers.Anyhow("buildx", "stop", data.Identifier("-container")) - helpers.Anyhow("buildx", "rm", "--force", data.Identifier("-container")) + helpers.Anyhow("buildx", "stop", data.Identifier("container")) + helpers.Anyhow("buildx", "rm", "--force", data.Identifier("container")) } - helpers.Anyhow("rmi", "-f", data.Identifier("-parent")) - helpers.Anyhow("rmi", "-f", data.Identifier("-child")) + helpers.Anyhow("rmi", "-f", data.Identifier("parent")) + helpers.Anyhow("rmi", "-f", data.Identifier("child")) }, Setup: func(data test.Data, helpers test.Helpers) { // Default docker driver does not support OCI exporter. // Reference: https://docs.docker.com/build/exporters/oci-docker/ if nerdtest.IsDocker() { - name := data.Identifier("-container") + name := data.Identifier("container") helpers.Ensure("buildx", "create", "--name", name, "--driver=docker-container") dockerBuilderArgs = []string{"buildx", "--builder", name} } @@ -63,25 +63,21 @@ func TestBuildContextWithOCILayout(t *testing.T) { LABEL layer=oci-layout-parent CMD ["echo", "test-nerdctl-build-context-oci-layout-parent"]`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) + data.Temp().Save(dockerfile, "Dockerfile") + dest := data.Temp().Dir("parent") + tarPath := data.Temp().Path("parent.tar") - tarPath := filepath.Join(buildCtx, "parent.tar") - dest := filepath.Join(buildCtx, "parent") - assert.NilError(helpers.T(), os.MkdirAll(dest, 0o700)) - helpers.Ensure("build", buildCtx, "--tag", data.Identifier("-parent")) - helpers.Ensure("image", "save", "--output", tarPath, data.Identifier("-parent")) - helpers.Custom("tar", "Cxf", dest, tarPath).Run(&test.Expected{}) + helpers.Ensure("build", data.Temp().Path(), "--tag", data.Identifier("parent")) + helpers.Ensure("image", "save", "--output", tarPath, data.Identifier("parent")) + helpers.Custom("tar", "Cxf", dest, tarPath).Run(&test.Expected{ + ExitCode: expect.ExitCodeSuccess, + }) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { dockerfile := `FROM parent CMD ["echo", "test-nerdctl-build-context-oci-layout"]` - - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) + data.Temp().Save(dockerfile, "Dockerfile") var cmd test.TestableCommand if nerdtest.IsDocker() { @@ -89,7 +85,13 @@ CMD ["echo", "test-nerdctl-build-context-oci-layout"]` } else { cmd = helpers.Command() } - cmd.WithArgs("build", buildCtx, fmt.Sprintf("--build-context=parent=oci-layout://%s", filepath.Join(buildCtx, "parent")), "--tag", data.Identifier("-child")) + cmd.WithArgs( + "build", + data.Temp().Path(), + fmt.Sprintf("--build-context=parent=oci-layout://%s", filepath.Join(data.Temp().Path(), "parent")), + "--tag", + data.Identifier("child"), + ) if nerdtest.IsDocker() { // Need to load the container image from the builder to be able to run it. cmd.WithArgs("--load") @@ -99,7 +101,14 @@ CMD ["echo", "test-nerdctl-build-context-oci-layout"]` Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: func(stdout string, info string, t *testing.T) { - assert.Assert(t, strings.Contains(helpers.Capture("run", "--rm", data.Identifier("-child")), "test-nerdctl-build-context-oci-layout"), info) + assert.Assert( + t, + strings.Contains( + helpers.Capture("run", "--rm", data.Identifier("child")), + "test-nerdctl-build-context-oci-layout", + ), + info, + ) }, } }, diff --git a/cmd/nerdctl/builder/builder_build_test.go b/cmd/nerdctl/builder/builder_build_test.go index e4999a927ee..3260be3e4ba 100644 --- a/cmd/nerdctl/builder/builder_build_test.go +++ b/cmd/nerdctl/builder/builder_build_test.go @@ -19,8 +19,6 @@ package builder import ( "errors" "fmt" - "os" - "path/filepath" "runtime" "strings" "testing" @@ -39,23 +37,20 @@ import ( func TestBuildBasics(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", data.TempDir()) - }, - Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Identifier()) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { Description: "Successfully build with 'tag first', 'buildctx second'", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", "-t", data.Identifier(), data.Get("buildCtx")) + helpers.Ensure("build", "-t", data.Identifier(), data.Labels().Get("buildCtx")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -63,12 +58,12 @@ CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, { Description: "Successfully build with 'buildctx first', 'tag second'", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -76,12 +71,18 @@ CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, { Description: "Successfully build with output docker, main tag still works", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "-t", data.Identifier(), "--output=type=docker,name="+data.Identifier("ignored")) + helpers.Ensure( + "build", + data.Labels().Get("buildCtx"), + "-t", + data.Identifier(), + "--output=type=docker,name="+data.Identifier("ignored"), + ) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -89,18 +90,24 @@ CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, { Description: "Successfully build with output docker, name cannot be used", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "-t", data.Identifier(), "--output=type=docker,name="+data.Identifier("ignored")) + helpers.Ensure( + "build", + data.Labels().Get("buildCtx"), + "-t", + data.Identifier(), + "--output=type=docker,name="+data.Identifier("ignored"), + ) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier("ignored")) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Identifier()) + helpers.Anyhow("rmi", "-f", data.Identifier("ignored")) }, Expected: test.Expects(expect.ExitCodeGenericFail, nil, nil), }, @@ -122,32 +129,39 @@ func TestCanBuildOnOtherPlatform(t *testing.T) { can, err := platformutil.CanExecProbably("linux/" + candidateArch) assert.NilError(helpers.T(), err) - data.Set("OS", "linux") - data.Set("Architecture", candidateArch) + data.Labels().Set("OS", "linux") + data.Labels().Set("Architecture", candidateArch) return can, "Current environment does not support emulation" }, } + dockerfile := fmt.Sprintf(`FROM %s +RUN echo hello > /hello +CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, requireEmulation, ), Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -RUN echo hello > /hello -CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", data.TempDir()) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "--platform", fmt.Sprintf("%s/%s", data.Get("OS"), data.Get("Architecture")), "-t", data.Identifier()) + return helpers.Command( + "build", + data.Labels().Get("buildCtx"), + "--platform", + fmt.Sprintf("%s/%s", data.Labels().Get("OS"), data.Labels().Get("Architecture")), + "-t", + data.Identifier(), + ) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, nil), + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), } testCase.Run(t) @@ -168,21 +182,19 @@ func TestBuildBaseImage(t *testing.T) { dockerfile := fmt.Sprintf(`FROM %s RUN echo hello > /hello CMD ["echo", "nerdctl-build-test-string"]`, testutil.CommonImage) - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", "-t", data.Identifier("first"), data.TempDir()) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", "-t", data.Identifier("first"), data.Temp().Path()) dockerfileSecond := fmt.Sprintf(`FROM %s RUN echo hello2 > /hello2 CMD ["cat", "/hello2"]`, data.Identifier("first")) - err = os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfileSecond), 0644) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", "-t", data.Identifier("second"), data.TempDir()) + data.Temp().Save(dockerfileSecond, "Dockerfile") + helpers.Ensure("build", "-t", data.Identifier("second"), data.Temp().Path()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier("second")) }, - Expected: test.Expects(0, nil, expect.Equals("hello2\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("hello2\n")), } testCase.Run(t) @@ -209,14 +221,13 @@ func TestBuildFromContainerd(t *testing.T) { dockerfile := fmt.Sprintf(`FROM %s RUN echo hello2 > /hello2 CMD ["cat", "/hello2"]`, data.Identifier("first")) - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", "-t", data.Identifier("second"), data.TempDir()) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", "-t", data.Identifier("second"), data.Temp().Path()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier("second")) }, - Expected: test.Expects(0, nil, expect.Equals("hello2\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("hello2\n")), } testCase.Run(t) @@ -225,14 +236,15 @@ CMD ["cat", "/hello2"]`, data.Identifier("first")) func TestBuildFromStdin(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-stdin"]`, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-stdin"]`, testutil.CommonImage) cmd := helpers.Command("build", "-t", data.Identifier(), "-f", "-", ".") cmd.Feed(strings.NewReader(dockerfile)) return cmd @@ -250,21 +262,15 @@ CMD ["echo", "nerdctl-build-test-stdin"]`, testutil.CommonImage) func TestBuildWithDockerfile(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-dockerfile"] + `, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, - Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Identifier()) - }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-dockerfile"] - `, testutil.CommonImage) - buildCtx := filepath.Join(data.TempDir(), "test") - err := os.MkdirAll(buildCtx, 0755) - assert.NilError(helpers.T(), err) - err = os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "test", "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path("test")) }, SubTests: []*test.Case{ { @@ -274,10 +280,10 @@ CMD ["echo", "nerdctl-build-test-dockerfile"] }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { cmd := helpers.Command("build", "-t", data.Identifier(), "-f", "Dockerfile", "..") - cmd.WithCwd(data.Get("buildCtx")) + cmd.WithCwd(data.Labels().Get("buildCtx")) return cmd }, - Expected: test.Expects(0, nil, nil), + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), }, { Description: "Dockerfile .", @@ -286,16 +292,16 @@ CMD ["echo", "nerdctl-build-test-dockerfile"] }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { cmd := helpers.Command("build", "-t", data.Identifier(), "-f", "Dockerfile", ".") - cmd.WithCwd(data.Get("buildCtx")) + cmd.WithCwd(data.Labels().Get("buildCtx")) return cmd }, - Expected: test.Expects(0, nil, nil), + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), }, { Description: "../Dockerfile .", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { cmd := helpers.Command("build", "-t", data.Identifier(), "-f", "../Dockerfile", ".") - cmd.WithCwd(data.Get("buildCtx")) + cmd.WithCwd(data.Labels().Get("buildCtx")) return cmd }, Expected: test.Expects(1, nil, nil), @@ -312,53 +318,41 @@ func TestBuildLocal(t *testing.T) { const testFileName = "nerdctl-build-test" const testContent = "nerdctl" + dockerfile := fmt.Sprintf(`FROM scratch +COPY %s /`, testFileName) + testCase := &test.Case{ Require: nerdtest.Build, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM scratch -COPY %s /`, testFileName) - - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - - err = os.WriteFile(filepath.Join(data.TempDir(), testFileName), []byte(testContent), 0644) - assert.NilError(helpers.T(), err) - - data.Set("buildCtx", data.TempDir()) + data.Temp().Save(dockerfile, "Dockerfile") + data.Temp().Save(testContent, testFileName) + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { - Description: "destination 1", + // GOTCHA: avoid comma and = in the test name, or buildctl will misparse the destination direction + Description: "-o type local destination DIR: verify the file copied from context is in the output directory", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", "-o", fmt.Sprintf("type=local,dest=%s", data.TempDir()), data.Get("buildCtx")) + return helpers.Command("build", "-o", fmt.Sprintf("type=local,dest=%s", data.Temp().Path()), data.Labels().Get("buildCtx")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - testFilePath := filepath.Join(data.TempDir(), testFileName) - _, err := os.Stat(testFilePath) - assert.NilError(helpers.T(), err, info) - dt, err := os.ReadFile(testFilePath) - assert.NilError(helpers.T(), err, info) - assert.Equal(helpers.T(), string(dt), testContent, info) + Output: func(stdout, info string, t *testing.T) { + // Expecting testFileName to exist inside the output target directory + assert.Equal(t, data.Temp().Load(testFileName), testContent, "file content is identical") }, } }, }, { - Description: "destination 2", + Description: "-o DIR: verify the file copied from context is in the output directory", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", "-o", data.TempDir(), data.Get("buildCtx")) + return helpers.Command("build", "-o", data.Temp().Path(), data.Labels().Get("buildCtx")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - testFilePath := filepath.Join(data.TempDir(), testFileName) - _, err := os.Stat(testFilePath) - assert.NilError(helpers.T(), err, info) - dt, err := os.ReadFile(testFilePath) - assert.NilError(helpers.T(), err, info) - assert.Equal(helpers.T(), string(dt), testContent, info) + Output: func(stdout, info string, t *testing.T) { + assert.Equal(t, data.Temp().Load(testFileName), testContent, "file content is identical") }, } }, @@ -372,27 +366,26 @@ COPY %s /`, testFileName) func TestBuildWithBuildArg(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +ARG TEST_STRING=1 +ENV TEST_STRING=$TEST_STRING +CMD echo $TEST_STRING + `, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -ARG TEST_STRING=1 -ENV TEST_STRING=$TEST_STRING -CMD echo $TEST_STRING - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { Description: "No args", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -400,12 +393,12 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("1\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("1\n")), }, { Description: "ArgValueOverridesDefault", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "TEST_STRING=2", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "TEST_STRING=2", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -413,12 +406,12 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("2\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("2\n")), }, { Description: "EmptyArgValueOverridesDefault", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "TEST_STRING=", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "TEST_STRING=", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -426,12 +419,12 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("\n")), }, { Description: "UnsetArgKeyPreservesDefault", Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -439,7 +432,7 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("1\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("1\n")), }, { Description: "EnvValueOverridesDefault", @@ -447,7 +440,7 @@ CMD echo $TEST_STRING "TEST_STRING": "3", }, Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -455,7 +448,7 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("3\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("3\n")), }, { Description: "EmptyEnvValueOverridesDefault", @@ -463,7 +456,7 @@ CMD echo $TEST_STRING "TEST_STRING": "", }, Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "TEST_STRING", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) @@ -471,7 +464,7 @@ CMD echo $TEST_STRING Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("\n")), }, }, } @@ -482,27 +475,24 @@ CMD echo $TEST_STRING func TestBuildWithIIDFile(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-string"] + `, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-string"] - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx, "--iidfile", filepath.Join(data.TempDir(), "id.txt"), "-t", data.Identifier()) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", data.Temp().Path(), "--iidfile", data.Temp().Path("id.txt"), "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - imageID, err := os.ReadFile(filepath.Join(data.TempDir(), "id.txt")) - assert.NilError(helpers.T(), err) - return helpers.Command("run", "--rm", string(imageID)) + return helpers.Command("run", "--rm", data.Temp().Load("id.txt")) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), } testCase.Run(t) @@ -511,25 +501,24 @@ CMD ["echo", "nerdctl-build-test-string"] func TestBuildWithLabels(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +LABEL name=nerdctl-build-test-label + `, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -LABEL name=nerdctl-build-test-label - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx, "--label", "label=test", "-t", data.Identifier()) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", data.Temp().Path(), "--label", "label=test", "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("inspect", data.Identifier(), "--format", "{{json .Config.Labels }}") }, - Expected: test.Expects(0, nil, expect.Equals("{\"label\":\"test\",\"name\":\"nerdctl-build-test-label\"}\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("{\"label\":\"test\",\"name\":\"nerdctl-build-test-label\"}\n")), } testCase.Run(t) @@ -538,49 +527,54 @@ LABEL name=nerdctl-build-test-label func TestBuildMultipleTags(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-string"] + `, testutil.CommonImage) + testCase := &test.Case{ Require: nerdtest.Build, - Data: test.WithData("i1", "image"). - Set("i2", "image2"). - Set("i3", "image3:hello"), Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Get("i1")) - helpers.Anyhow("rmi", "-f", data.Get("i2")) - helpers.Anyhow("rmi", "-f", data.Get("i3")) + helpers.Anyhow("rmi", "-f", data.Labels().Get("i1")) + helpers.Anyhow("rmi", "-f", data.Labels().Get("i2")) + helpers.Anyhow("rmi", "-f", data.Labels().Get("i3")) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-string"] - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx, "-t", data.Get("i1"), "-t", data.Get("i2"), "-t", data.Get("i3")) + data.Labels().Set("i1", data.Identifier("image")) + data.Labels().Set("i2", data.Identifier("image2")) + data.Labels().Set("i3", data.Identifier("image3")+":hello") + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure( + "build", + data.Temp().Path(), + "-t", data.Labels().Get("i1"), + "-t", data.Labels().Get("i2"), + "-t", data.Labels().Get("i3"), + ) }, SubTests: []*test.Case{ { Description: "i1", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get("i1")) + return helpers.Command("run", "--rm", data.Labels().Get("i1")) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, { Description: "i2", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get("i2")) + return helpers.Command("run", "--rm", data.Labels().Get("i2")) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, { Description: "i3", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get("i3")) + return helpers.Command("run", "--rm", data.Labels().Get("i3")) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), }, }, } @@ -591,6 +585,10 @@ CMD ["echo", "nerdctl-build-test-string"] func TestBuildWithContainerfile(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-string"] + `, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, @@ -600,18 +598,13 @@ func TestBuildWithContainerfile(t *testing.T) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-string"] - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Containerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx, "-t", data.Identifier()) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", data.Temp().Path(), "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("nerdctl-build-test-string\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("nerdctl-build-test-string\n")), } testCase.Run(t) @@ -629,20 +622,19 @@ func TestBuildWithDockerFileAndContainerfile(t *testing.T) { dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "dockerfile"] `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) + data.Temp().Save(dockerfile, "Dockerfile") + dockerfile = fmt.Sprintf(`FROM %s CMD ["echo", "containerfile"] `, testutil.CommonImage) - err = os.WriteFile(filepath.Join(buildCtx, "Containerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx, "-t", data.Identifier()) + data.Temp().Save(dockerfile, "Containerfile") + + helpers.Ensure("build", data.Temp().Path(), "-t", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("dockerfile\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("dockerfile\n")), } testCase.Run(t) @@ -651,6 +643,10 @@ CMD ["echo", "containerfile"] func TestBuildNoTag(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +CMD ["echo", "nerdctl-build-test-string"] + `, testutil.CommonImage) + // FIXME: this test should be rewritten and instead get the image id from the build, then query the image explicitly - instead of pruning / noparallel testCase := &test.Case{ NoParallel: true, @@ -659,16 +655,13 @@ func TestBuildNoTag(t *testing.T) { helpers.Ensure("image", "prune", "--force", "--all") }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -CMD ["echo", "nerdctl-build-test-string"] - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + + // XXX FIXME + helpers.Capture("build", data.Temp().Path()) }, Command: test.Command("images"), - Expected: test.Expects(0, nil, expect.Contains("")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Contains("")), } testCase.Run(t) @@ -677,23 +670,27 @@ CMD ["echo", "nerdctl-build-test-string"] func TestBuildContextDockerImageAlias(t *testing.T) { nerdtest.Setup() + dockerfile := `FROM myorg/myapp +CMD ["echo", "nerdctl-build-myorg/myapp"]` + testCase := &test.Case{ Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := `FROM myorg/myapp -CMD ["echo", "nerdctl-build-myorg/myapp"]` - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", "-t", data.Identifier(), data.Get("buildCtx"), fmt.Sprintf("--build-context=myorg/myapp=docker-image://%s", testutil.CommonImage)) - }, - Expected: test.Expects(0, nil, nil), + return helpers.Command( + "build", + "-t", + data.Identifier(), + data.Temp().Path(), + fmt.Sprintf("--build-context=myorg/myapp=docker-image://%s", testutil.CommonImage), + ) + }, + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), } testCase.Run(t) @@ -704,6 +701,9 @@ func TestBuildContextWithCopyFromDir(t *testing.T) { content := "hello_from_dir_2" filename := "hello.txt" + dockerfile := fmt.Sprintf(`FROM %s +COPY --from=dir2 /%s /hello_from_dir2.txt +RUN ["cat", "/hello_from_dir2.txt"]`, testutil.CommonImage, filename) testCase := &test.Case{ Require: require.All( @@ -714,23 +714,19 @@ func TestBuildContextWithCopyFromDir(t *testing.T) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dir2 := helpers.T().TempDir() - filePath := filepath.Join(dir2, filename) - err := os.WriteFile(filePath, []byte(content), 0o600) - assert.NilError(helpers.T(), err) - dockerfile := fmt.Sprintf(`FROM %s -COPY --from=dir2 /%s /hello_from_dir2.txt -RUN ["cat", "/hello_from_dir2.txt"]`, testutil.CommonImage, filename) - buildCtx := data.TempDir() - err = os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) - data.Set("dir2", dir2) + data.Temp().Save(dockerfile, "context", "Dockerfile") + data.Temp().Save(content, "other-directory", filename) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", "-t", data.Identifier(), data.Get("buildCtx"), fmt.Sprintf("--build-context=dir2=%s", data.Get("dir2"))) - }, - Expected: test.Expects(0, nil, nil), + return helpers.Command( + "build", + "-t", + data.Identifier(), + data.Temp().Path("context"), + fmt.Sprintf("--build-context=dir2=%s", data.Temp().Path("other-directory")), + ) + }, + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), } testCase.Run(t) @@ -741,24 +737,20 @@ RUN ["cat", "/hello_from_dir2.txt"]`, testutil.CommonImage, filename) func TestBuildSourceDateEpoch(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +ARG SOURCE_DATE_EPOCH +RUN echo $SOURCE_DATE_EPOCH >/source-date-epoch +CMD ["cat", "/source-date-epoch"] + `, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, require.Not(nerdtest.Docker), ), - Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Identifier()) - }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -ARG SOURCE_DATE_EPOCH -RUN echo $SOURCE_DATE_EPOCH >/source-date-epoch -CMD ["cat", "/source-date-epoch"] - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { @@ -767,7 +759,7 @@ CMD ["cat", "/source-date-epoch"] "SOURCE_DATE_EPOCH": "1111111111", }, Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "-t", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) @@ -775,7 +767,7 @@ CMD ["cat", "/source-date-epoch"] Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("1111111111\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("1111111111\n")), }, { Description: "2222222222", @@ -783,7 +775,7 @@ CMD ["cat", "/source-date-epoch"] "SOURCE_DATE_EPOCH": "1111111111", }, Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("build", data.Get("buildCtx"), "--build-arg", "SOURCE_DATE_EPOCH=2222222222", "-t", data.Identifier()) + helpers.Ensure("build", data.Labels().Get("buildCtx"), "--build-arg", "SOURCE_DATE_EPOCH=2222222222", "-t", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) @@ -791,7 +783,7 @@ CMD ["cat", "/source-date-epoch"] Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("run", "--rm", data.Identifier()) }, - Expected: test.Expects(0, nil, expect.Equals("2222222222\n")), + Expected: test.Expects(expect.ExitCodeSuccess, nil, expect.Equals("2222222222\n")), }, }, } @@ -802,29 +794,25 @@ CMD ["cat", "/source-date-epoch"] func TestBuildNetwork(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +RUN apk add --no-cache curl +RUN curl -I http://google.com + `, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, require.Not(nerdtest.Docker), ), - Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rmi", "-f", data.Identifier()) - }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -RUN apk add --no-cache curl -RUN curl -I http://google.com - `, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { Description: "none", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "none") + return helpers.Command("build", data.Labels().Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "none") }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) @@ -834,22 +822,22 @@ RUN curl -I http://google.com { Description: "empty", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "") + return helpers.Command("build", data.Labels().Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "") }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, nil), + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), }, { Description: "default", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "default") + return helpers.Command("build", data.Labels().Get("buildCtx"), "-t", data.Identifier(), "--no-cache", "--network", "default") }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, - Expected: test.Expects(0, nil, nil), + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), }, }, } @@ -863,6 +851,8 @@ func TestBuildAttestation(t *testing.T) { const testSBOMFileName = "sbom.spdx.json" const testProvenanceFileName = "provenance.json" + dockerfile := fmt.Sprintf(`FROM %s`, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, @@ -872,38 +862,34 @@ func TestBuildAttestation(t *testing.T) { if nerdtest.IsDocker() { helpers.Anyhow("buildx", "rm", data.Identifier("builder")) } - helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { if nerdtest.IsDocker() { helpers.Anyhow("buildx", "create", "--name", data.Identifier("builder"), "--bootstrap", "--use") } - dockerfile := fmt.Sprintf(`FROM %s`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("buildCtx", data.Temp().Path()) }, SubTests: []*test.Case{ { Description: "SBOM", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - outputSBOMDir := helpers.T().TempDir() - data.Set("outputSBOMFile", filepath.Join(outputSBOMDir, testSBOMFileName)) - cmd := helpers.Command("build") if nerdtest.IsDocker() { cmd.WithArgs("--builder", data.Identifier("builder")) } - cmd.WithArgs("--sbom=true", "-o", fmt.Sprintf("type=local,dest=%s", outputSBOMDir), data.Get("buildCtx")) + cmd.WithArgs( + "--sbom=true", + "-o", fmt.Sprintf("type=local,dest=%s", data.Temp().Path("dir-for-bom")), + data.Labels().Get("buildCtx"), + ) return cmd }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - _, err := os.Stat(data.Get("outputSBOMFile")) - assert.NilError(t, err, info) + Output: func(stdout, info string, t *testing.T) { + data.Temp().Exists("dir-for-bom", testSBOMFileName) }, } }, @@ -911,21 +897,21 @@ func TestBuildAttestation(t *testing.T) { { Description: "Provenance", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - outputProvenanceDir := data.TempDir() - data.Set("outputProvenanceFile", filepath.Join(outputProvenanceDir, testProvenanceFileName)) - cmd := helpers.Command("build") if nerdtest.IsDocker() { cmd.WithArgs("--builder", data.Identifier("builder")) } - cmd.WithArgs("--provenance=mode=min", "-o", fmt.Sprintf("type=local,dest=%s", outputProvenanceDir), data.Get("buildCtx")) + cmd.WithArgs( + "--provenance=mode=min", + "-o", fmt.Sprintf("type=local,dest=%s", data.Temp().Path("dir-for-prov")), + data.Labels().Get("buildCtx"), + ) return cmd }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - _, err := os.Stat(data.Get("outputProvenanceFile")) - assert.NilError(t, err, info) + Output: func(stdout, info string, t *testing.T) { + data.Temp().Exists("dir-for-prov", testProvenanceFileName) }, } }, @@ -933,24 +919,23 @@ func TestBuildAttestation(t *testing.T) { { Description: "Attestation", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - outputAttestationDir := data.TempDir() - data.Set("outputSBOMFile", filepath.Join(outputAttestationDir, testSBOMFileName)) - data.Set("outputProvenanceFile", filepath.Join(outputAttestationDir, testProvenanceFileName)) - cmd := helpers.Command("build") if nerdtest.IsDocker() { cmd.WithArgs("--builder", data.Identifier("builder")) } - cmd.WithArgs("--attest=type=provenance,mode=min", "--attest=type=sbom", "-o", fmt.Sprintf("type=local,dest=%s", outputAttestationDir), data.Get("buildCtx")) + cmd.WithArgs( + "--attest=type=provenance,mode=min", + "--attest=type=sbom", + "-o", fmt.Sprintf("type=local,dest=%s", data.Temp().Path("dir-for-attest")), + data.Labels().Get("buildCtx"), + ) return cmd }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - _, err := os.Stat(data.Get("outputSBOMFile")) - assert.NilError(t, err, info) - _, err = os.Stat(data.Get("outputProvenanceFile")) - assert.NilError(t, err, info) + Output: func(stdout, info string, t *testing.T) { + data.Temp().Exists("dir-for-attest", testSBOMFileName) + data.Temp().Exists("dir-for-attest", testProvenanceFileName) }, } }, @@ -964,6 +949,11 @@ func TestBuildAttestation(t *testing.T) { func TestBuildAddHost(t *testing.T) { nerdtest.Setup() + dockerfile := fmt.Sprintf(`FROM %s +RUN ping -c 5 alpha +RUN ping -c 5 beta +`, testutil.CommonImage) + testCase := &test.Case{ Require: require.All( nerdtest.Build, @@ -972,19 +962,17 @@ func TestBuildAddHost(t *testing.T) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Setup: func(data test.Data, helpers test.Helpers) { - dockerfile := fmt.Sprintf(`FROM %s -RUN ping -c 5 alpha -RUN ping -c 5 beta -`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "-t", data.Identifier(), "--add-host", "alpha:127.0.0.1", "--add-host", "beta:127.0.0.1") - }, - Expected: test.Expects(0, nil, nil), + return helpers.Command( + "build", data.Temp().Path(), + "-t", data.Identifier(), + "--add-host", "alpha:127.0.0.1", + "--add-host", "beta:127.0.0.1", + ) + }, + Expected: test.Expects(expect.ExitCodeSuccess, nil, nil), } testCase.Run(t) diff --git a/cmd/nerdctl/builder/builder_builder_test.go b/cmd/nerdctl/builder/builder_builder_test.go index a049e566380..fdbfa1990ac 100644 --- a/cmd/nerdctl/builder/builder_builder_test.go +++ b/cmd/nerdctl/builder/builder_builder_test.go @@ -17,15 +17,11 @@ package builder import ( - "bytes" "errors" "fmt" - "os" - "path/filepath" + "strings" "testing" - "gotest.tools/v3/assert" - "github.com/containerd/nerdctl/mod/tigron/require" "github.com/containerd/nerdctl/mod/tigron/test" @@ -49,10 +45,8 @@ func TestBuilder(t *testing.T) { Setup: func(data test.Data, helpers test.Helpers) { dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "nerdctl-test-builder-prune"]`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", data.Temp().Path()) }, Command: test.Command("builder", "prune", "--force"), Expected: test.Expects(0, nil, nil), @@ -63,10 +57,8 @@ CMD ["echo", "nerdctl-test-builder-prune"]`, testutil.CommonImage) Setup: func(data test.Data, helpers test.Helpers) { dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "nerdctl-test-builder-prune"]`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - helpers.Ensure("build", buildCtx) + data.Temp().Save(dockerfile, "Dockerfile") + helpers.Ensure("build", data.Temp().Path()) }, Command: test.Command("builder", "prune", "--force", "--all"), Expected: test.Expects(0, nil, nil), @@ -79,11 +71,9 @@ CMD ["echo", "nerdctl-test-builder-prune"]`, testutil.CommonImage) Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "nerdctl-builder-debug-test-string"]`, testutil.CommonImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - cmd := helpers.Command("builder", "debug", buildCtx) - cmd.Feed(bytes.NewReader([]byte("c\n"))) + data.Temp().Save(dockerfile, "Dockerfile") + cmd := helpers.Command("builder", "debug", data.Temp().Path()) + cmd.Feed(strings.NewReader("c\n")) return cmd }, Expected: test.Expects(0, nil, nil), @@ -103,13 +93,10 @@ CMD ["echo", "nerdctl-builder-debug-test-string"]`, testutil.CommonImage) helpers.Ensure("tag", oldImage, newImage) dockerfile := fmt.Sprintf(`FROM %s`, newImage) - buildCtx := data.TempDir() - err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) - assert.NilError(helpers.T(), err) - - data.Set("buildCtx", buildCtx) - data.Set("oldImageSha", oldImageSha) - data.Set("newImageSha", newImageSha) + data.Temp().Save(dockerfile, "Dockerfile") + data.Labels().Set("oldImageSha", oldImageSha) + data.Labels().Set("newImageSha", newImageSha) + data.Labels().Set("base", data.Temp().Dir()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", testutil.AlpineImage) @@ -119,11 +106,11 @@ CMD ["echo", "nerdctl-builder-debug-test-string"]`, testutil.CommonImage) Description: "pull false", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "--pull=false") + return helpers.Command("build", data.Labels().Get("base"), "--pull=false") }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Errors: []error{errors.New(data.Get("oldImageSha"))}, + Errors: []error{errors.New(data.Labels().Get("oldImageSha"))}, } }, }, @@ -131,11 +118,11 @@ CMD ["echo", "nerdctl-builder-debug-test-string"]`, testutil.CommonImage) Description: "pull true", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx"), "--pull=true") + return helpers.Command("build", data.Labels().Get("base"), "--pull=true") }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Errors: []error{errors.New(data.Get("newImageSha"))}, + Errors: []error{errors.New(data.Labels().Get("newImageSha"))}, } }, }, @@ -143,11 +130,11 @@ CMD ["echo", "nerdctl-builder-debug-test-string"]`, testutil.CommonImage) Description: "no pull", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx")) + return helpers.Command("build", data.Labels().Get("base")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Errors: []error{errors.New(data.Get("newImageSha"))}, + Errors: []error{errors.New(data.Labels().Get("newImageSha"))}, } }, }, diff --git a/cmd/nerdctl/completion/completion_test.go b/cmd/nerdctl/completion/completion_test.go index 23bdf833c52..bde281ab497 100644 --- a/cmd/nerdctl/completion/completion_test.go +++ b/cmd/nerdctl/completion/completion_test.go @@ -41,7 +41,7 @@ func TestCompletion(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) helpers.Ensure("network", "create", identifier) helpers.Ensure("volume", "create", identifier) - data.Set("identifier", identifier) + data.Labels().Set("identifier", identifier) }, Cleanup: func(data test.Data, helpers test.Helpers) { identifier := data.Identifier() @@ -93,7 +93,7 @@ func TestCompletion(t *testing.T) { return &test.Expected{ Output: expect.All( expect.Contains("host\n"), - expect.Contains(data.Get("identifier")+"\n"), + expect.Contains(data.Labels().Get("identifier")+"\n"), ), } }, @@ -105,7 +105,7 @@ func TestCompletion(t *testing.T) { return &test.Expected{ Output: expect.All( expect.Contains("host\n"), - expect.Contains(data.Get("identifier")+"\n"), + expect.Contains(data.Labels().Get("identifier")+"\n"), ), } }, @@ -117,7 +117,7 @@ func TestCompletion(t *testing.T) { return &test.Expected{ Output: expect.All( expect.Contains("host\n"), - expect.Contains(data.Get("identifier")+"\n"), + expect.Contains(data.Labels().Get("identifier")+"\n"), ), } }, @@ -134,7 +134,7 @@ func TestCompletion(t *testing.T) { return &test.Expected{ Output: expect.All( expect.DoesNotContain("host\n"), - expect.Contains(data.Get("identifier")+"\n"), + expect.Contains(data.Labels().Get("identifier")+"\n"), ), } }, @@ -153,7 +153,7 @@ func TestCompletion(t *testing.T) { Command: test.Command("__complete", "volume", "inspect", ""), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("identifier") + "\n"), + Output: expect.Contains(data.Labels().Get("identifier") + "\n"), } }, }, @@ -162,7 +162,7 @@ func TestCompletion(t *testing.T) { Command: test.Command("__complete", "volume", "rm", ""), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("identifier") + "\n"), + Output: expect.Contains(data.Labels().Get("identifier") + "\n"), } }, }, diff --git a/cmd/nerdctl/container/container_commit_linux_test.go b/cmd/nerdctl/container/container_commit_linux_test.go index 8da0ee01b4f..e1a167c0633 100644 --- a/cmd/nerdctl/container/container_commit_linux_test.go +++ b/cmd/nerdctl/container/container_commit_linux_test.go @@ -45,7 +45,7 @@ func TestKubeCommitSave(t *testing.T) { containerID = strings.TrimPrefix(stdout, "containerd://") }, }) - data.Set("containerID", containerID) + data.Labels().Set("containerID", containerID) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -53,7 +53,7 @@ func TestKubeCommitSave(t *testing.T) { } testCase.Command = func(data test.Data, helpers test.Helpers) test.TestableCommand { - helpers.Ensure("commit", data.Get("containerID"), "testcommitsave") + helpers.Ensure("commit", data.Labels().Get("containerID"), "testcommitsave") return helpers.Command("save", "testcommitsave") } diff --git a/cmd/nerdctl/container/container_create_linux_test.go b/cmd/nerdctl/container/container_create_linux_test.go index 0a20ddac9c2..3ea83d8ac96 100644 --- a/cmd/nerdctl/container/container_create_linux_test.go +++ b/cmd/nerdctl/container/container_create_linux_test.go @@ -199,7 +199,7 @@ func TestIssue2993(t *testing.T) { { Description: "Issue #2993 - nerdctl no longer leaks containers and etchosts directories and files when container creation fails.", Setup: func(data test.Data, helpers test.Helpers) { - dataRoot := data.TempDir() + dataRoot := data.Temp().Path() helpers.Ensure("run", "--data-root", dataRoot, "--name", data.Identifier(), "-d", testutil.AlpineImage, "sleep", nerdtest.Infinity) @@ -218,25 +218,25 @@ func TestIssue2993(t *testing.T) { assert.NilError(t, err) assert.Equal(t, len(etchostsDirs), 1) - data.Set(containersPathKey, containersPath) - data.Set(etchostsPathKey, etchostsPath) + data.Labels().Set(containersPathKey, containersPath) + data.Labels().Set(etchostsPathKey, etchostsPath) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rm", "--data-root", data.TempDir(), "-f", data.Identifier()) + helpers.Anyhow("rm", "--data-root", data.Temp().Path(), "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--data-root", data.TempDir(), "--name", data.Identifier(), "-d", testutil.AlpineImage, "sleep", nerdtest.Infinity) + return helpers.Command("run", "--data-root", data.Temp().Path(), "--name", data.Identifier(), "-d", testutil.AlpineImage, "sleep", nerdtest.Infinity) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: 1, Errors: []error{errors.New("is already used by ID")}, Output: func(stdout string, info string, t *testing.T) { - containersDirs, err := os.ReadDir(data.Get(containersPathKey)) + containersDirs, err := os.ReadDir(data.Labels().Get(containersPathKey)) assert.NilError(t, err) assert.Equal(t, len(containersDirs), 1) - etchostsDirs, err := os.ReadDir(data.Get(etchostsPathKey)) + etchostsDirs, err := os.ReadDir(data.Labels().Get(etchostsPathKey)) assert.NilError(t, err) assert.Equal(t, len(etchostsDirs), 1) }, @@ -246,7 +246,7 @@ func TestIssue2993(t *testing.T) { { Description: "Issue #2993 - nerdctl no longer leaks containers and etchosts directories and files when containers are removed.", Setup: func(data test.Data, helpers test.Helpers) { - dataRoot := data.TempDir() + dataRoot := data.Temp().Path() helpers.Ensure("run", "--data-root", dataRoot, "--name", data.Identifier(), "-d", testutil.AlpineImage, "sleep", nerdtest.Infinity) @@ -265,25 +265,25 @@ func TestIssue2993(t *testing.T) { assert.NilError(t, err) assert.Equal(t, len(etchostsDirs), 1) - data.Set(containersPathKey, containersPath) - data.Set(etchostsPathKey, etchostsPath) + data.Labels().Set(containersPathKey, containersPath) + data.Labels().Set(etchostsPathKey, etchostsPath) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("--data-root", data.TempDir(), "rm", "-f", data.Identifier()) + helpers.Anyhow("--data-root", data.Temp().Path(), "rm", "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("--data-root", data.TempDir(), "rm", "-f", data.Identifier()) + return helpers.Command("--data-root", data.Temp().Path(), "rm", "-f", data.Identifier()) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: 0, Errors: []error{}, Output: func(stdout string, info string, t *testing.T) { - containersDirs, err := os.ReadDir(data.Get(containersPathKey)) + containersDirs, err := os.ReadDir(data.Labels().Get(containersPathKey)) assert.NilError(t, err) assert.Equal(t, len(containersDirs), 0) - etchostsDirs, err := os.ReadDir(data.Get(etchostsPathKey)) + etchostsDirs, err := os.ReadDir(data.Labels().Get(etchostsPathKey)) assert.NilError(t, err) assert.Equal(t, len(etchostsDirs), 0) }, diff --git a/cmd/nerdctl/container/container_create_test.go b/cmd/nerdctl/container/container_create_test.go index 8b507d37fc6..f10536eecce 100644 --- a/cmd/nerdctl/container/container_create_test.go +++ b/cmd/nerdctl/container/container_create_test.go @@ -35,7 +35,7 @@ func TestCreate(t *testing.T) { testCase := nerdtest.Setup() testCase.Setup = func(data test.Data, helpers test.Helpers) { helpers.Ensure("create", "--name", data.Identifier("container"), testutil.CommonImage, "echo", "foo") - data.Set("cID", data.Identifier("container")) + data.Labels().Set("cID", data.Identifier("container")) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier("container")) @@ -55,7 +55,7 @@ func TestCreate(t *testing.T) { Description: "start", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("start", data.Get("cID")) + return helpers.Command("start", data.Labels().Get("cID")) }, Expected: test.Expects(0, nil, nil), }, @@ -63,7 +63,7 @@ func TestCreate(t *testing.T) { Description: "logs", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("logs", data.Get("cID")) + return helpers.Command("logs", data.Labels().Get("cID")) }, Expected: test.Expects(0, nil, expect.Contains("foo")), }, @@ -79,7 +79,7 @@ func TestCreateHyperVContainer(t *testing.T) { testCase.Setup = func(data test.Data, helpers test.Helpers) { helpers.Ensure("create", "--isolation", "hyperv", "--name", data.Identifier("container"), testutil.CommonImage, "echo", "foo") - data.Set("cID", data.Identifier("container")) + data.Labels().Set("cID", data.Identifier("container")) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -98,10 +98,10 @@ func TestCreateHyperVContainer(t *testing.T) { Description: "start", NoParallel: true, Setup: func(data test.Data, helpers test.Helpers) { - helpers.Ensure("start", data.Get("cID")) + helpers.Ensure("start", data.Labels().Get("cID")) ran := false for i := 0; i < 10 && !ran; i++ { - helpers.Command("container", "inspect", data.Get("cID")). + helpers.Command("container", "inspect", data.Labels().Get("cID")). Run(&test.Expected{ ExitCode: expect.ExitCodeNoCheck, Output: func(stdout string, info string, t *testing.T) { @@ -119,7 +119,7 @@ func TestCreateHyperVContainer(t *testing.T) { assert.Assert(t, ran, "container did not ran after 10 seconds") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("logs", data.Get("cID")) + return helpers.Command("logs", data.Labels().Get("cID")) }, Expected: test.Expects(0, nil, expect.Contains("foo")), }, diff --git a/cmd/nerdctl/container/container_exec_linux_test.go b/cmd/nerdctl/container/container_exec_linux_test.go index c5624085643..5ff812d9429 100644 --- a/cmd/nerdctl/container/container_exec_linux_test.go +++ b/cmd/nerdctl/container/container_exec_linux_test.go @@ -65,14 +65,14 @@ func TestExecTTY(t *testing.T) { testCase.Setup = func(data test.Data, helpers test.Helpers) { helpers.Ensure("run", "-d", "--name", data.Identifier(), testutil.CommonImage, "sleep", nerdtest.Infinity) - data.Set("container_name", data.Identifier()) + data.Labels().Set("container_name", data.Identifier()) } testCase.SubTests = []*test.Case{ { Description: "stty with -it", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Command("exec", "-it", data.Get("container_name"), "stty") + cmd := helpers.Command("exec", "-it", data.Labels().Get("container_name"), "stty") cmd.WithPseudoTTY() return cmd }, @@ -81,7 +81,7 @@ func TestExecTTY(t *testing.T) { { Description: "stty with -t", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Command("exec", "-t", data.Get("container_name"), "stty") + cmd := helpers.Command("exec", "-t", data.Labels().Get("container_name"), "stty") cmd.WithPseudoTTY() return cmd }, @@ -90,7 +90,7 @@ func TestExecTTY(t *testing.T) { { Description: "stty with -i", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Command("exec", "-i", data.Get("container_name"), "stty") + cmd := helpers.Command("exec", "-i", data.Labels().Get("container_name"), "stty") cmd.WithPseudoTTY() return cmd }, @@ -99,7 +99,7 @@ func TestExecTTY(t *testing.T) { { Description: "stty without params", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Command("exec", data.Get("container_name"), "stty") + cmd := helpers.Command("exec", data.Labels().Get("container_name"), "stty") cmd.WithPseudoTTY() return cmd }, diff --git a/cmd/nerdctl/container/container_inspect_linux_test.go b/cmd/nerdctl/container/container_inspect_linux_test.go index c03a0a472ea..b070359fa00 100644 --- a/cmd/nerdctl/container/container_inspect_linux_test.go +++ b/cmd/nerdctl/container/container_inspect_linux_test.go @@ -531,10 +531,10 @@ RUN groupadd -r test && useradd -r -g test test USER test `, testutil.UbuntuImage) - err := os.WriteFile(filepath.Join(data.TempDir(), "Dockerfile"), []byte(dockerfile), 0o600) + err := os.WriteFile(filepath.Join(data.Temp().Path(), "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) - helpers.Ensure("build", "-t", data.Identifier(), data.TempDir()) + helpers.Ensure("build", "-t", data.Identifier(), data.Temp().Path()) helpers.Ensure("create", "--name", data.Identifier(), "--user", "test", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { diff --git a/cmd/nerdctl/container/container_restart_linux_test.go b/cmd/nerdctl/container/container_restart_linux_test.go index 95b404099cd..55996bcbcd4 100644 --- a/cmd/nerdctl/container/container_restart_linux_test.go +++ b/cmd/nerdctl/container/container_restart_linux_test.go @@ -136,7 +136,7 @@ func TestRestartWithSignal(t *testing.T) { testCase.Command = func(data test.Data, helpers test.Helpers) test.TestableCommand { cmd := nerdtest.RunSigProxyContainer(nerdtest.SigUsr1, false, nil, data, helpers) // Capture the current pid - data.Set("oldpid", strconv.Itoa(nerdtest.InspectContainer(helpers, data.Identifier()).State.Pid)) + data.Labels().Set("oldpid", strconv.Itoa(nerdtest.InspectContainer(helpers, data.Identifier()).State.Pid)) // Send the signal helpers.Ensure("restart", "--signal", "SIGUSR1", data.Identifier()) return cmd @@ -154,7 +154,7 @@ func TestRestartWithSignal(t *testing.T) { nerdtest.EnsureContainerStarted(helpers, data.Identifier()) // Check the new pid is different newpid := strconv.Itoa(nerdtest.InspectContainer(helpers, data.Identifier()).State.Pid) - assert.Assert(helpers.T(), newpid != data.Get("oldpid"), info) + assert.Assert(helpers.T(), newpid != data.Labels().Get("oldpid"), info) }, ), } diff --git a/cmd/nerdctl/container/container_run_cgroup_linux_test.go b/cmd/nerdctl/container/container_run_cgroup_linux_test.go index 2e1fce340df..564e1a74d3f 100644 --- a/cmd/nerdctl/container/container_run_cgroup_linux_test.go +++ b/cmd/nerdctl/container/container_run_cgroup_linux_test.go @@ -242,7 +242,7 @@ func TestRunDevice(t *testing.T) { 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) + data.Labels().Set("loContent"+strconv.Itoa(i), loContent) } // lo0 is readable but not writable. @@ -254,7 +254,7 @@ func TestRunDevice(t *testing.T) { "--device", lo[0].Device+":r", "--device", lo[1].Device, testutil.AlpineImage, "sleep", nerdtest.Infinity) - data.Set("id", data.Identifier()) + data.Labels().Set("id", data.Identifier()) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -270,25 +270,25 @@ func TestRunDevice(t *testing.T) { { 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) + return helpers.Command("exec", data.Labels().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")), + Output: expect.Contains(data.Labels().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) + return helpers.Command("exec", data.Labels().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) + return helpers.Command("exec", data.Labels().Get("id"), "cat", lo[2].Device) }, Expected: test.Expects(expect.ExitCodeGenericFail, nil, nil), }, @@ -296,11 +296,11 @@ func TestRunDevice(t *testing.T) { 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) + return helpers.Command("exec", data.Labels().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")), + Output: expect.Contains(data.Labels().Get("locontent1")), } }, }, @@ -308,7 +308,7 @@ func TestRunDevice(t *testing.T) { 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) + return helpers.Command("exec", data.Labels().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) diff --git a/cmd/nerdctl/container/container_run_network_linux_test.go b/cmd/nerdctl/container/container_run_network_linux_test.go index e275669fa38..853e14e8ab5 100644 --- a/cmd/nerdctl/container/container_run_network_linux_test.go +++ b/cmd/nerdctl/container/container_run_network_linux_test.go @@ -363,10 +363,10 @@ func TestRunWithInvalidPortThenCleanUp(t *testing.T) { { Description: "Run a container with invalid ports, and then clean up.", Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rm", "--data-root", data.TempDir(), "-f", data.Identifier()) + helpers.Anyhow("rm", "--data-root", data.Temp().Path(), "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--data-root", data.TempDir(), "--rm", "--name", data.Identifier(), "-p", "22200-22299:22200-22299", testutil.CommonImage) + return helpers.Command("run", "--data-root", data.Temp().Path(), "--rm", "--name", data.Identifier(), "-p", "22200-22299:22200-22299", testutil.CommonImage) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -382,7 +382,7 @@ func TestRunWithInvalidPortThenCleanUp(t *testing.T) { return h } - dataRoot := data.TempDir() + dataRoot := data.Temp().Path() h := getAddrHash(defaults.DefaultAddress) dataStore := filepath.Join(dataRoot, h) namespace := string(helpers.Read(nerdtest.Namespace)) @@ -519,8 +519,8 @@ func TestSharedNetworkSetup(t *testing.T) { testCase := &test.Case{ Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("containerName1", data.Identifier("-container1")) - containerName1 := data.Get("containerName1") + data.Labels().Set("containerName1", data.Identifier("-container1")) + containerName1 := data.Labels().Get("containerName1") helpers.Ensure("run", "-d", "--name", containerName1, testutil.NginxAlpineImage) }, @@ -538,7 +538,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.NginxAlpineImage) return cmd }, @@ -547,7 +547,7 @@ func TestSharedNetworkSetup(t *testing.T) { Output: func(stdout string, info string, t *testing.T) { containerName2 := data.Identifier() assert.Assert(t, strings.Contains(helpers.Capture("exec", containerName2, "wget", "-qO-", "http://127.0.0.1:80"), testutil.NginxAlpineIndexHTMLSnippet), info) - helpers.Ensure("restart", data.Get("containerName1")) + helpers.Ensure("restart", data.Labels().Get("containerName1")) helpers.Ensure("stop", "--time=1", containerName2) helpers.Ensure("start", containerName2) assert.Assert(t, strings.Contains(helpers.Capture("exec", containerName2, "wget", "-qO-", "http://127.0.0.1:80"), testutil.NginxAlpineIndexHTMLSnippet), info) @@ -564,7 +564,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, "--uts", "host", - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.AlpineImage) return cmd }, @@ -583,7 +583,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, "--dns", "0.1.2.3", - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.AlpineImage) return cmd }, @@ -608,7 +608,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "--name", containerName2, "--dns-option", "attempts:5", - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.AlpineImage, "cat", "/etc/resolv.conf") return cmd }, @@ -631,7 +631,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, "--publish", "80:8080", - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.AlpineImage) return cmd }, @@ -656,7 +656,7 @@ func TestSharedNetworkSetup(t *testing.T) { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, "--hostname", "test", - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.AlpineImage) return cmd }, @@ -682,19 +682,19 @@ func TestSharedNetworkWithNone(t *testing.T) { testCase := &test.Case{ Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("containerName1", data.Identifier("-container1")) - containerName1 := data.Get("containerName1") + data.Labels().Set("containerName1", data.Identifier("-container1")) + containerName1 := data.Labels().Get("containerName1") helpers.Ensure("run", "-d", "--name", containerName1, "--network", "none", testutil.NginxAlpineImage) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("rm", "-f", data.Get("containerName1")) + helpers.Anyhow("rm", "-f", data.Labels().Get("containerName1")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { containerName2 := data.Identifier() cmd := helpers.Command() cmd.WithArgs("run", "-d", "--name", containerName2, - "--network=container:"+data.Get("containerName1"), + "--network=container:"+data.Labels().Get("containerName1"), testutil.NginxAlpineImage) return cmd }, @@ -927,7 +927,7 @@ func TestNoneNetworkHostName(t *testing.T) { Setup: func(data test.Data, helpers test.Helpers) { output := helpers.Capture("run", "-d", "--name", data.Identifier(), "--network", "none", testutil.NginxAlpineImage) assert.Assert(helpers.T(), len(output) > 12, output) - data.Set("hostname", output[:12]) + data.Labels().Set("hostname", output[:12]) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) @@ -937,7 +937,7 @@ func TestNoneNetworkHostName(t *testing.T) { }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Equals(data.Get("hostname") + "\n"), + Output: expect.Equals(data.Labels().Get("hostname") + "\n"), } }, } @@ -949,7 +949,7 @@ func TestHostNetworkHostName(t *testing.T) { testCase := &test.Case{ Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("containerName1", data.Identifier()) + data.Labels().Set("containerName1", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) @@ -974,7 +974,7 @@ func TestNoneNetworkDnsConfigs(t *testing.T) { testCase := &test.Case{ Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("containerName1", data.Identifier()) + data.Labels().Set("containerName1", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) @@ -1003,7 +1003,7 @@ func TestHostNetworkDnsConfigs(t *testing.T) { testCase := &test.Case{ Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("containerName1", data.Identifier()) + data.Labels().Set("containerName1", data.Identifier()) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) diff --git a/cmd/nerdctl/container/container_stats_test.go b/cmd/nerdctl/container/container_stats_test.go index 0648d502d94..59132d156a1 100644 --- a/cmd/nerdctl/container/container_stats_test.go +++ b/cmd/nerdctl/container/container_stats_test.go @@ -53,7 +53,7 @@ func TestStats(t *testing.T) { helpers.Ensure("run", "-d", "--name", data.Identifier("container"), testutil.CommonImage, "sleep", nerdtest.Infinity) helpers.Ensure("run", "-d", "--name", data.Identifier("memlimited"), "--memory", "1g", testutil.CommonImage, "sleep", nerdtest.Infinity) helpers.Ensure("run", "--name", data.Identifier("exited"), testutil.CommonImage, "echo", "'exited'") - data.Set("id", data.Identifier("container")) + data.Labels().Set("id", data.Identifier("container")) } testCase.SubTests = []*test.Case{ @@ -62,7 +62,7 @@ func TestStats(t *testing.T) { Command: test.Command("stats", "--no-stream", "--no-trunc"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("id")), + Output: expect.Contains(data.Labels().Get("id")), } }, }, @@ -71,21 +71,21 @@ func TestStats(t *testing.T) { Command: test.Command("container", "stats", "--no-stream", "--no-trunc"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("id")), + Output: expect.Contains(data.Labels().Get("id")), } }, }, { Description: "stats ID", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("stats", "--no-stream", data.Get("id")) + return helpers.Command("stats", "--no-stream", data.Labels().Get("id")) }, Expected: test.Expects(0, nil, nil), }, { Description: "container stats ID", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("container", "stats", "--no-stream", data.Get("id")) + return helpers.Command("container", "stats", "--no-stream", data.Labels().Get("id")) }, Expected: test.Expects(0, nil, nil), }, diff --git a/cmd/nerdctl/container/container_top_test.go b/cmd/nerdctl/container/container_top_test.go index 6f18721b14e..e63d71f4150 100644 --- a/cmd/nerdctl/container/container_top_test.go +++ b/cmd/nerdctl/container/container_top_test.go @@ -38,7 +38,7 @@ func TestTop(t *testing.T) { testCase.Setup = func(data test.Data, helpers test.Helpers) { // FIXME: busybox 1.36 on windows still appears to not support sleep inf. Unclear why. helpers.Ensure("run", "-d", "--name", data.Identifier(), testutil.CommonImage, "sleep", nerdtest.Infinity) - data.Set("cID", data.Identifier()) + data.Labels().Set("cID", data.Identifier()) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -51,7 +51,7 @@ func TestTop(t *testing.T) { // Docker does not support top -o Require: require.Not(nerdtest.Docker), Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("top", data.Get("cID"), "-o", "pid,user,cmd") + return helpers.Command("top", data.Labels().Get("cID"), "-o", "pid,user,cmd") }, Expected: test.Expects(0, nil, nil), @@ -59,7 +59,7 @@ func TestTop(t *testing.T) { { Description: "simple", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("top", data.Get("cID")) + return helpers.Command("top", data.Labels().Get("cID")) }, Expected: test.Expects(0, nil, nil), diff --git a/cmd/nerdctl/image/image_convert_linux_test.go b/cmd/nerdctl/image/image_convert_linux_test.go index 3d2615741bc..b26358ec8b9 100644 --- a/cmd/nerdctl/image/image_convert_linux_test.go +++ b/cmd/nerdctl/image/image_convert_linux_test.go @@ -115,16 +115,16 @@ func TestImageConvertNydusVerify(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) base := testutil.NewBase(t) registry = testregistry.NewWithNoAuth(base, 0, false) - data.Set(remoteImageKey, fmt.Sprintf("%s:%d/nydusd-image:test", "localhost", registry.Port)) + data.Labels().Set(remoteImageKey, fmt.Sprintf("%s:%d/nydusd-image:test", "localhost", registry.Port)) helpers.Ensure("image", "convert", "--nydus", "--oci", testutil.CommonImage, data.Identifier("converted-image")) - helpers.Ensure("tag", data.Identifier("converted-image"), data.Get(remoteImageKey)) - helpers.Ensure("push", data.Get(remoteImageKey)) + helpers.Ensure("tag", data.Identifier("converted-image"), data.Labels().Get(remoteImageKey)) + helpers.Ensure("push", data.Labels().Get(remoteImageKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier("converted-image")) if registry != nil { registry.Cleanup(nil) - helpers.Anyhow("rmi", "-f", data.Get(remoteImageKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(remoteImageKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { @@ -133,7 +133,7 @@ func TestImageConvertNydusVerify(t *testing.T) { "--source", testutil.CommonImage, "--target", - data.Get(remoteImageKey), + data.Labels().Get(remoteImageKey), "--source-insecure", "--target-insecure", ) diff --git a/cmd/nerdctl/image/image_encrypt_linux_test.go b/cmd/nerdctl/image/image_encrypt_linux_test.go index ac883133f63..f8d34dc03cb 100644 --- a/cmd/nerdctl/image/image_encrypt_linux_test.go +++ b/cmd/nerdctl/image/image_encrypt_linux_test.go @@ -51,7 +51,7 @@ func TestImageEncryptJWE(t *testing.T) { if registry != nil { registry.Cleanup(nil) keyPair.Cleanup() - helpers.Anyhow("rmi", "-f", data.Get(remoteImageKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(remoteImageKey)) } helpers.Anyhow("rmi", "-f", data.Identifier("decrypted")) }, @@ -69,13 +69,13 @@ func TestImageEncryptJWE(t *testing.T) { helpers.Ensure("push", encryptImageRef) helpers.Anyhow("rmi", "-f", encryptImageRef) helpers.Anyhow("rmi", "-f", testutil.CommonImage) - data.Set(remoteImageKey, encryptImageRef) + data.Labels().Set(remoteImageKey, encryptImageRef) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - helpers.Fail("pull", data.Get(remoteImageKey)) - helpers.Ensure("pull", "--quiet", "--unpack=false", data.Get(remoteImageKey)) - helpers.Fail("image", "decrypt", "--key="+keyPair.Pub, data.Get(remoteImageKey), data.Identifier("decrypted")) // decryption needs prv key, not pub key - return helpers.Command("image", "decrypt", "--key="+keyPair.Prv, data.Get(remoteImageKey), data.Identifier("decrypted")) + helpers.Fail("pull", data.Labels().Get(remoteImageKey)) + helpers.Ensure("pull", "--quiet", "--unpack=false", data.Labels().Get(remoteImageKey)) + helpers.Fail("image", "decrypt", "--key="+keyPair.Pub, data.Labels().Get(remoteImageKey), data.Identifier("decrypted")) // decryption needs prv key, not pub key + return helpers.Command("image", "decrypt", "--key="+keyPair.Prv, data.Labels().Get(remoteImageKey), data.Identifier("decrypted")) }, Expected: test.Expects(0, nil, nil), } diff --git a/cmd/nerdctl/image/image_history_test.go b/cmd/nerdctl/image/image_history_test.go index 699a7cf6fe1..1281c00fa47 100644 --- a/cmd/nerdctl/image/image_history_test.go +++ b/cmd/nerdctl/image/image_history_test.go @@ -83,7 +83,7 @@ func TestImageHistory(t *testing.T) { // XXX: despite efforts to isolate this test, it keeps on having side effects linked to // https://github.com/containerd/nerdctl/issues/3512 // Isolating it into a completely different root is the last ditched attempt at avoiding the issue - helpers.Write(nerdtest.DataRoot, test.ConfigValue(data.TempDir())) + helpers.Write(nerdtest.DataRoot, test.ConfigValue(data.Temp().Path())) helpers.Ensure("pull", "--quiet", "--platform", "linux/arm64", testutil.CommonImage) }, SubTests: []*test.Case{ diff --git a/cmd/nerdctl/image/image_list_test.go b/cmd/nerdctl/image/image_list_test.go index 8956d2d9f77..a1db81ee440 100644 --- a/cmd/nerdctl/image/image_list_test.go +++ b/cmd/nerdctl/image/image_list_test.go @@ -148,10 +148,10 @@ LABEL foo=bar LABEL version=0.1 RUN echo "actually creating a layer so that docker sets the createdAt time" `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Labels().Set("buildCtx", buildCtx) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", "taggedimage:one-fragment-one") @@ -159,8 +159,8 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" helpers.Anyhow("rmi", "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - data.Set("builtImageID", data.Identifier()) - return helpers.Command("build", "-t", data.Identifier(), data.Get("buildCtx")) + data.Labels().Set("builtImageID", data.Identifier()) + return helpers.Command("build", "-t", data.Identifier(), data.Labels().Get("buildCtx")) }, Expected: test.Expects(0, nil, nil), SubTests: []*test.Case{ @@ -169,7 +169,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Command: test.Command("images", "--filter", "label=foo=bar"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("builtImageID")), + Output: expect.Contains(data.Labels().Get("builtImageID")), } }, }, @@ -178,7 +178,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Command: test.Command("images", "--filter", "label=foo=bar1"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.DoesNotContain(data.Get("builtImageID")), + Output: expect.DoesNotContain(data.Labels().Get("builtImageID")), } }, }, @@ -187,7 +187,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Command: test.Command("images", "--filter", "label=foo=bar", "--filter", "label=version=0.1"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("builtImageID")), + Output: expect.Contains(data.Labels().Get("builtImageID")), } }, }, @@ -196,7 +196,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Command: test.Command("images", "--filter", "label=foo=bar", "--filter", "label=version=0.2"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.DoesNotContain(data.Get("builtImageID")), + Output: expect.DoesNotContain(data.Labels().Get("builtImageID")), } }, }, @@ -205,18 +205,18 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Command: test.Command("images", "--filter", "label=version"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("builtImageID")), + Output: expect.Contains(data.Labels().Get("builtImageID")), } }, }, { Description: "reference=ID*", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("images", "--filter", fmt.Sprintf("reference=%s*", data.Get("builtImageID"))) + return helpers.Command("images", "--filter", fmt.Sprintf("reference=%s*", data.Labels().Get("builtImageID"))) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ - Output: expect.Contains(data.Get("builtImageID")), + Output: expect.Contains(data.Labels().Get("builtImageID")), } }, }, @@ -231,13 +231,13 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" { Description: "before=ID:latest", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("images", "--filter", fmt.Sprintf("before=%s:latest", data.Get("builtImageID"))) + return helpers.Command("images", "--filter", fmt.Sprintf("before=%s:latest", data.Labels().Get("builtImageID"))) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( expect.Contains(testutil.ImageRepo(testutil.CommonImage)), - expect.DoesNotContain(data.Get("builtImageID")), + expect.DoesNotContain(data.Labels().Get("builtImageID")), ), } }, @@ -248,7 +248,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("builtImageID")), + expect.Contains(data.Labels().Get("builtImageID")), expect.DoesNotContain(testutil.ImageRepo(testutil.CommonImage)), ), } @@ -260,7 +260,7 @@ RUN echo "actually creating a layer so that docker sets the createdAt time" Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.DoesNotContain(data.Get("builtImageID")), + expect.DoesNotContain(data.Labels().Get("builtImageID")), expect.DoesNotContain(testutil.ImageRepo(testutil.CommonImage)), ), } @@ -296,17 +296,17 @@ func TestImagesFilterDangling(t *testing.T) { dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "nerdctl-build-notag-string"] `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) - data.Set("buildCtx", buildCtx) + data.Labels().Set("buildCtx", buildCtx) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("container", "prune", "-f") helpers.Anyhow("image", "prune", "--all", "-f") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("build", data.Get("buildCtx")) + return helpers.Command("build", data.Labels().Get("buildCtx")) }, Expected: test.Expects(0, nil, nil), SubTests: []*test.Case{ diff --git a/cmd/nerdctl/image/image_load_test.go b/cmd/nerdctl/image/image_load_test.go index fc1fa549da4..6598ab93db5 100644 --- a/cmd/nerdctl/image/image_load_test.go +++ b/cmd/nerdctl/image/image_load_test.go @@ -43,7 +43,7 @@ func TestLoadStdinFromPipe(t *testing.T) { identifier := data.Identifier() helpers.Ensure("pull", "--quiet", testutil.CommonImage) helpers.Ensure("tag", testutil.CommonImage, identifier) - helpers.Ensure("save", identifier, "-o", filepath.Join(data.TempDir(), "common.tar")) + helpers.Ensure("save", identifier, "-o", filepath.Join(data.Temp().Path(), "common.tar")) helpers.Ensure("rmi", "-f", identifier) }, Cleanup: func(data test.Data, helpers test.Helpers) { @@ -51,7 +51,7 @@ func TestLoadStdinFromPipe(t *testing.T) { }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { cmd := helpers.Command("load") - reader, err := os.Open(filepath.Join(data.TempDir(), "common.tar")) + reader, err := os.Open(filepath.Join(data.Temp().Path(), "common.tar")) assert.NilError(t, err, "failed to open common.tar") cmd.Feed(reader) return cmd @@ -94,14 +94,14 @@ func TestLoadQuiet(t *testing.T) { identifier := data.Identifier() helpers.Ensure("pull", "--quiet", testutil.CommonImage) helpers.Ensure("tag", testutil.CommonImage, identifier) - helpers.Ensure("save", identifier, "-o", filepath.Join(data.TempDir(), "common.tar")) + helpers.Ensure("save", identifier, "-o", filepath.Join(data.Temp().Path(), "common.tar")) helpers.Ensure("rmi", "-f", identifier) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier()) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("load", "--quiet", "--input", filepath.Join(data.TempDir(), "common.tar")) + return helpers.Command("load", "--quiet", "--input", filepath.Join(data.Temp().Path(), "common.tar")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ diff --git a/cmd/nerdctl/image/image_prune_test.go b/cmd/nerdctl/image/image_prune_test.go index 1c8b402e332..402ea7bb94a 100644 --- a/cmd/nerdctl/image/image_prune_test.go +++ b/cmd/nerdctl/image/image_prune_test.go @@ -71,7 +71,7 @@ func TestImagePrune(t *testing.T) { CMD ["echo", "nerdctl-test-image-prune"] `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", buildCtx) @@ -119,7 +119,7 @@ func TestImagePrune(t *testing.T) { CMD ["echo", "nerdctl-test-image-prune"] `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", buildCtx) @@ -163,7 +163,7 @@ func TestImagePrune(t *testing.T) { CMD ["echo", "nerdctl-test-image-prune-filter-label"] LABEL foo=bar LABEL version=0.1`, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", "-t", data.Identifier(), buildCtx) @@ -203,22 +203,22 @@ LABEL version=0.1`, testutil.CommonImage) dockerfile := fmt.Sprintf(`FROM %s RUN echo "Anything, so that we create actual content for docker to set the current time for CreatedAt" CMD ["echo", "nerdctl-test-image-prune-until"]`, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", "-t", data.Identifier(), buildCtx) imgList := helpers.Capture("images") assert.Assert(t, strings.Contains(imgList, data.Identifier()), "Missing "+data.Identifier()) - data.Set("imageID", data.Identifier()) + data.Labels().Set("imageID", data.Identifier()) }, Command: test.Command("image", "prune", "--force", "--all", "--filter", "until=12h"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.DoesNotContain(data.Get("imageID")), + expect.DoesNotContain(data.Labels().Get("imageID")), func(stdout string, info string, t *testing.T) { imgList := helpers.Capture("images") - assert.Assert(t, strings.Contains(imgList, data.Get("imageID")), info) + assert.Assert(t, strings.Contains(imgList, data.Labels().Get("imageID")), info) }, ), } @@ -234,10 +234,10 @@ CMD ["echo", "nerdctl-test-image-prune-until"]`, testutil.CommonImage) Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("imageID")), + expect.Contains(data.Labels().Get("imageID")), func(stdout string, info string, t *testing.T) { imgList := helpers.Capture("images") - assert.Assert(t, !strings.Contains(imgList, data.Get("imageID")), imgList, info) + assert.Assert(t, !strings.Contains(imgList, data.Labels().Get("imageID")), imgList, info) }, ), } diff --git a/cmd/nerdctl/image/image_pull_linux_test.go b/cmd/nerdctl/image/image_pull_linux_test.go index 9939bc72529..6156b82a3e2 100644 --- a/cmd/nerdctl/image/image_pull_linux_test.go +++ b/cmd/nerdctl/image/image_pull_linux_test.go @@ -61,7 +61,7 @@ func TestImagePullWithCosign(t *testing.T) { CMD ["echo", "nerdctl-build-test-string"] `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", "-t", testImageRef+":one", buildCtx) @@ -69,7 +69,7 @@ CMD ["echo", "nerdctl-build-test-string"] helpers.Ensure("push", "--sign=cosign", "--cosign-key="+keyPair.PrivateKey, testImageRef+":one") helpers.Ensure("push", "--sign=cosign", "--cosign-key="+keyPair.PrivateKey, testImageRef+":two") helpers.Ensure("rmi", "-f", testImageRef) - data.Set("imageref", testImageRef) + data.Labels().Set("imageref", testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { if keyPair != nil { @@ -86,7 +86,7 @@ CMD ["echo", "nerdctl-build-test-string"] { Description: "Pull with the correct key", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("pull", "--quiet", "--verify=cosign", "--cosign-key="+keyPair.PublicKey, data.Get("imageref")+":one") + return helpers.Command("pull", "--quiet", "--verify=cosign", "--cosign-key="+keyPair.PublicKey, data.Labels().Get("imageref")+":one") }, Expected: test.Expects(0, nil, nil), }, @@ -97,7 +97,7 @@ CMD ["echo", "nerdctl-build-test-string"] }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { newKeyPair := testhelpers.NewCosignKeyPair(t, "cosign-key-pair-test", "2") - return helpers.Command("pull", "--quiet", "--verify=cosign", "--cosign-key="+newKeyPair.PublicKey, data.Get("imageref")+":two") + return helpers.Command("pull", "--quiet", "--verify=cosign", "--cosign-key="+newKeyPair.PublicKey, data.Labels().Get("imageref")+":two") }, Expected: test.Expects(12, nil, nil), }, @@ -127,7 +127,7 @@ func TestImagePullPlainHttpWithDefaultPort(t *testing.T) { CMD ["echo", "nerdctl-build-test-string"] `, testutil.CommonImage) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) helpers.Ensure("build", "-t", testImageRef, buildCtx) @@ -169,13 +169,15 @@ func TestImagePullSoci(t *testing.T) { { Description: "Run without specifying SOCI index", NoParallel: true, - Data: test.WithData("remoteSnapshotsExpectedCount", "11"). - Set("sociIndexDigest", ""), + Data: test.WithLabels(map[string]string{ + "remoteSnapshotsExpectedCount": "11", + "sociIndexDigest": "", + }), Setup: func(data test.Data, helpers test.Helpers) { cmd := helpers.Custom("mount") cmd.Run(&test.Expected{ Output: func(stdout string, info string, t *testing.T) { - data.Set("remoteSnapshotsInitialCount", strconv.Itoa(strings.Count(stdout, "fuse.rawBridge"))) + data.Labels().Set("remoteSnapshotsInitialCount", strconv.Itoa(strings.Count(stdout, "fuse.rawBridge"))) }, }) helpers.Ensure("--snapshotter=soci", "pull", testutil.FfmpegSociImage) @@ -189,10 +191,10 @@ func TestImagePullSoci(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: func(stdout string, info string, t *testing.T) { - remoteSnapshotsInitialCount, _ := strconv.Atoi(data.Get("remoteSnapshotsInitialCount")) + remoteSnapshotsInitialCount, _ := strconv.Atoi(data.Labels().Get("remoteSnapshotsInitialCount")) remoteSnapshotsActualCount := strings.Count(stdout, "fuse.rawBridge") assert.Equal(t, - data.Get("remoteSnapshotsExpectedCount"), + data.Labels().Get("remoteSnapshotsExpectedCount"), strconv.Itoa(remoteSnapshotsActualCount-remoteSnapshotsInitialCount), info) }, @@ -202,13 +204,15 @@ func TestImagePullSoci(t *testing.T) { { Description: "Run with bad SOCI index", NoParallel: true, - Data: test.WithData("remoteSnapshotsExpectedCount", "11"). - Set("sociIndexDigest", "sha256:thisisabadindex0000000000000000000000000000000000000000000000000"), + Data: test.WithLabels(map[string]string{ + "remoteSnapshotsExpectedCount": "11", + "sociIndexDigest": "sha256:thisisabadindex0000000000000000000000000000000000000000000000000", + }), Setup: func(data test.Data, helpers test.Helpers) { cmd := helpers.Custom("mount") cmd.Run(&test.Expected{ Output: func(stdout string, info string, t *testing.T) { - data.Set("remoteSnapshotsInitialCount", strconv.Itoa(strings.Count(stdout, "fuse.rawBridge"))) + data.Labels().Set("remoteSnapshotsInitialCount", strconv.Itoa(strings.Count(stdout, "fuse.rawBridge"))) }, }) helpers.Ensure("--snapshotter=soci", "pull", testutil.FfmpegSociImage) @@ -222,10 +226,10 @@ func TestImagePullSoci(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: func(stdout string, info string, t *testing.T) { - remoteSnapshotsInitialCount, _ := strconv.Atoi(data.Get("remoteSnapshotsInitialCount")) + remoteSnapshotsInitialCount, _ := strconv.Atoi(data.Labels().Get("remoteSnapshotsInitialCount")) remoteSnapshotsActualCount := strings.Count(stdout, "fuse.rawBridge") assert.Equal(t, - data.Get("remoteSnapshotsExpectedCount"), + data.Labels().Get("remoteSnapshotsExpectedCount"), strconv.Itoa(remoteSnapshotsActualCount-remoteSnapshotsInitialCount), info) }, diff --git a/cmd/nerdctl/image/image_push_linux_test.go b/cmd/nerdctl/image/image_push_linux_test.go index 66d26512a8a..bf10f371a23 100644 --- a/cmd/nerdctl/image/image_push_linux_test.go +++ b/cmd/nerdctl/image/image_push_linux_test.go @@ -67,16 +67,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryNoAuthHTTPRandom.IP.String(), registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", data.Get("testImageRef")) + return helpers.Command("push", data.Labels().Get("testImageRef")) }, Expected: test.Expects(1, []error{errors.New("server gave HTTP response to HTTPS client")}, nil), }, @@ -87,16 +87,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryNoAuthHTTPRandom.IP.String(), registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--insecure-registry", data.Get("testImageRef")) + return helpers.Command("push", "--insecure-registry", data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, @@ -106,11 +106,11 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", "127.0.0.1", registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", data.Get("testImageRef")) + return helpers.Command("push", data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, @@ -121,16 +121,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s/%s:%s", registryNoAuthHTTPDefault.IP.String(), data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--insecure-registry", data.Get("testImageRef")) + return helpers.Command("push", "--insecure-registry", data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, @@ -141,19 +141,19 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryTokenAuthHTTPSRandom.IP.String(), registryTokenAuthHTTPSRandom.Port, data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) helpers.Ensure("--insecure-registry", "login", "-u", "admin", "-p", "badmin", fmt.Sprintf("%s:%d", registryTokenAuthHTTPSRandom.IP.String(), registryTokenAuthHTTPSRandom.Port)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--insecure-registry", data.Get("testImageRef")) + return helpers.Command("push", "--insecure-registry", data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, @@ -164,19 +164,19 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryTokenAuthHTTPSRandom.IP.String(), registryTokenAuthHTTPSRandom.Port, data.Identifier(), strings.Split(testutil.CommonImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.CommonImage, testImageRef) helpers.Ensure("--hosts-dir", registryTokenAuthHTTPSRandom.HostsDir, "login", "-u", "admin", "-p", "badmin", fmt.Sprintf("%s:%d", registryTokenAuthHTTPSRandom.IP.String(), registryTokenAuthHTTPSRandom.Port)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--hosts-dir", registryTokenAuthHTTPSRandom.HostsDir, data.Get("testImageRef")) + return helpers.Command("push", "--hosts-dir", registryTokenAuthHTTPSRandom.HostsDir, data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, @@ -187,16 +187,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.NonDistBlobImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryNoAuthHTTPRandom.IP.String(), registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.NonDistBlobImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.NonDistBlobImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--insecure-registry", data.Get("testImageRef")) + return helpers.Command("push", "--insecure-registry", data.Labels().Get("testImageRef")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -219,16 +219,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.NonDistBlobImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryNoAuthHTTPRandom.IP.String(), registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.NonDistBlobImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.NonDistBlobImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--insecure-registry", "--allow-nondistributable-artifacts", data.Get("testImageRef")) + return helpers.Command("push", "--insecure-registry", "--allow-nondistributable-artifacts", data.Labels().Get("testImageRef")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -254,16 +254,16 @@ func TestPush(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.UbuntuImage) testImageRef := fmt.Sprintf("%s:%d/%s:%s", registryNoAuthHTTPRandom.IP.String(), registryNoAuthHTTPRandom.Port, data.Identifier(), strings.Split(testutil.UbuntuImage, ":")[1]) - data.Set("testImageRef", testImageRef) + data.Labels().Set("testImageRef", testImageRef) helpers.Ensure("tag", testutil.UbuntuImage, testImageRef) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("testImageRef") != "" { - helpers.Anyhow("rmi", "-f", data.Get("testImageRef")) + if data.Labels().Get("testImageRef") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("testImageRef")) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("push", "--snapshotter=soci", "--insecure-registry", "--soci-span-size=2097152", "--soci-min-layer-size=20971520", data.Get("testImageRef")) + return helpers.Command("push", "--snapshotter=soci", "--insecure-registry", "--soci-span-size=2097152", "--soci-min-layer-size=20971520", data.Labels().Get("testImageRef")) }, Expected: test.Expects(0, nil, nil), }, diff --git a/cmd/nerdctl/image/image_remove_test.go b/cmd/nerdctl/image/image_remove_test.go index e91f05c69af..db5fa47f722 100644 --- a/cmd/nerdctl/image/image_remove_test.go +++ b/cmd/nerdctl/image/image_remove_test.go @@ -129,11 +129,11 @@ func TestRemove(t *testing.T) { repoName, _ := imgutil.ParseRepoTag(testutil.CommonImage) imgShortID := strings.TrimPrefix(img.RepoDigests[0], repoName+"@sha256:")[0:8] - data.Set(imgShortIDKey, imgShortID) + data.Labels().Set(imgShortIDKey, imgShortID) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) - helpers.Anyhow("rmi", "-f", data.Get(imgShortIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(imgShortIDKey)) }, Command: test.Command("rmi", "-f", testutil.CommonImage), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { @@ -238,11 +238,11 @@ func TestRemove(t *testing.T) { repoName, _ := imgutil.ParseRepoTag(testutil.CommonImage) imgShortID := strings.TrimPrefix(img.RepoDigests[0], repoName+"@sha256:")[0:8] - data.Set(imgShortIDKey, imgShortID) + data.Labels().Set(imgShortIDKey, imgShortID) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) - helpers.Anyhow("rmi", "-f", data.Get(imgShortIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(imgShortIDKey)) }, Command: test.Command("rmi", "-f", testutil.CommonImage), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { @@ -330,17 +330,17 @@ func TestIssue3016(t *testing.T) { helpers.Ensure("tag", testutil.CommonImage, tagID) - data.Set(tagIDKey, tagID) + data.Labels().Set(tagIDKey, tagID) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("rmi", data.Get(tagIDKey)) + return helpers.Command("rmi", data.Labels().Get(tagIDKey)) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: 0, Errors: []error{}, Output: func(stdout string, info string, t *testing.T) { - helpers.Command("images", data.Get(tagIDKey)).Run(&test.Expected{ + helpers.Command("images", data.Labels().Get(tagIDKey)).Run(&test.Expected{ ExitCode: 0, Output: func(stdout string, info string, t *testing.T) { assert.Equal(t, len(strings.Split(stdout, "\n")), 2) diff --git a/cmd/nerdctl/image/image_save_test.go b/cmd/nerdctl/image/image_save_test.go index 7e61ef6e28f..4f3bf58de6a 100644 --- a/cmd/nerdctl/image/image_save_test.go +++ b/cmd/nerdctl/image/image_save_test.go @@ -44,13 +44,13 @@ func TestSaveContent(t *testing.T) { helpers.Ensure("pull", "--quiet", testutil.CommonImage) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("save", "-o", filepath.Join(data.TempDir(), "out.tar"), testutil.CommonImage) + return helpers.Command("save", "-o", filepath.Join(data.Temp().Path(), "out.tar"), testutil.CommonImage) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: func(stdout string, info string, t *testing.T) { - rootfsPath := filepath.Join(data.TempDir(), "rootfs") - err := testhelpers.ExtractDockerArchive(filepath.Join(data.TempDir(), "out.tar"), rootfsPath) + rootfsPath := filepath.Join(data.Temp().Path(), "rootfs") + err := testhelpers.ExtractDockerArchive(filepath.Join(data.Temp().Path(), "out.tar"), rootfsPath) assert.NilError(t, err) etcOSReleasePath := filepath.Join(rootfsPath, "/etc/os-release") etcOSReleaseBytes, err := os.ReadFile(etcOSReleasePath) @@ -83,8 +83,8 @@ func TestSave(t *testing.T) { Description: "Single image, by id", NoParallel: true, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("id") != "" { - helpers.Anyhow("rmi", "-f", data.Get("id")) + if data.Labels().Get("id") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("id")) } }, Setup: func(data test.Data, helpers test.Helpers) { @@ -97,14 +97,14 @@ func TestSave(t *testing.T) { } else { id = strings.Split(img.RepoDigests[0], ":")[1] } - tarPath := filepath.Join(data.TempDir(), "out.tar") + tarPath := filepath.Join(data.Temp().Path(), "out.tar") helpers.Ensure("save", "-o", tarPath, id) helpers.Ensure("rmi", "-f", testutil.CommonImage) helpers.Ensure("load", "-i", tarPath) - data.Set("id", id) + data.Labels().Set("id", id) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get("id"), "sh", "-euxc", "echo foo") + return helpers.Command("run", "--rm", data.Labels().Get("id"), "sh", "-euxc", "echo foo") }, Expected: test.Expects(0, nil, expect.Equals("foo\n")), }, @@ -112,8 +112,8 @@ func TestSave(t *testing.T) { Description: "Image with different names, by id", NoParallel: true, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("id") != "" { - helpers.Anyhow("rmi", "-f", data.Get("id")) + if data.Labels().Get("id") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("id")) } }, Setup: func(data test.Data, helpers test.Helpers) { @@ -126,14 +126,14 @@ func TestSave(t *testing.T) { id = strings.Split(img.RepoDigests[0], ":")[1] } helpers.Ensure("tag", testutil.CommonImage, data.Identifier()) - tarPath := filepath.Join(data.TempDir(), "out.tar") + tarPath := filepath.Join(data.Temp().Path(), "out.tar") helpers.Ensure("save", "-o", tarPath, id) helpers.Ensure("rmi", "-f", testutil.CommonImage) helpers.Ensure("load", "-i", tarPath) - data.Set("id", id) + data.Labels().Set("id", id) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get("id"), "sh", "-euxc", "echo foo") + return helpers.Command("run", "--rm", data.Labels().Get("id"), "sh", "-euxc", "echo foo") }, Expected: test.Expects(0, nil, expect.Equals("foo\n")), }, @@ -161,8 +161,8 @@ func TestSaveMultipleImagesWithSameIDAndLoad(t *testing.T) { Description: "Issue #3568 - Save multiple container images with the same image ID but different image names", NoParallel: true, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("id") != "" { - helpers.Anyhow("rmi", "-f", data.Get("id")) + if data.Labels().Get("id") != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get("id")) } }, Setup: func(data test.Data, helpers test.Helpers) { @@ -175,11 +175,11 @@ func TestSaveMultipleImagesWithSameIDAndLoad(t *testing.T) { id = strings.Split(img.RepoDigests[0], ":")[1] } helpers.Ensure("tag", testutil.CommonImage, data.Identifier()) - tarPath := filepath.Join(data.TempDir(), "out.tar") + tarPath := filepath.Join(data.Temp().Path(), "out.tar") helpers.Ensure("save", "-o", tarPath, testutil.CommonImage, data.Identifier()) helpers.Ensure("rmi", "-f", id) helpers.Ensure("load", "-i", tarPath) - data.Set("id", id) + data.Labels().Set("id", id) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("images", "--no-trunc") @@ -189,7 +189,7 @@ func TestSaveMultipleImagesWithSameIDAndLoad(t *testing.T) { ExitCode: 0, Errors: []error{}, Output: func(stdout string, info string, t *testing.T) { - assert.Equal(t, strings.Count(stdout, data.Get("id")), 2) + assert.Equal(t, strings.Count(stdout, data.Labels().Get("id")), 2) }, } }, diff --git a/cmd/nerdctl/ipfs/ipfs_compose_linux_test.go b/cmd/nerdctl/ipfs/ipfs_compose_linux_test.go index 2387555c0a3..9a7b09805b5 100644 --- a/cmd/nerdctl/ipfs/ipfs_compose_linux_test.go +++ b/cmd/nerdctl/ipfs/ipfs_compose_linux_test.go @@ -58,7 +58,7 @@ func TestIPFSCompNoBuild(t *testing.T) { // Start Kubo ipfsRegistry = registry.NewKuboRegistry(data, helpers, t, nil, 0, nil) ipfsRegistry.Setup(data, helpers) - data.Set(ipfsAddrKey, fmt.Sprintf("/ip4/%s/tcp/%d", ipfsRegistry.IP, ipfsRegistry.Port)) + data.Labels().Set(ipfsAddrKey, fmt.Sprintf("/ip4/%s/tcp/%d", ipfsRegistry.IP, ipfsRegistry.Port)) // Ensure we have the images helpers.Ensure("pull", "--quiet", testutil.WordpressImage) @@ -114,15 +114,15 @@ func subtestTestIPFSCompNoB(t *testing.T, stargz bool, byAddr bool) *test.Case { ipfsCIDWP = pushToIPFS(helpers, testutil.WordpressImage, "--estargz") ipfsCIDMD = pushToIPFS(helpers, testutil.MariaDBImage, "--estargz") } else if byAddr { - ipfsCIDWP = pushToIPFS(helpers, testutil.WordpressImage, "--ipfs-address="+data.Get(ipfsAddrKey)) - ipfsCIDMD = pushToIPFS(helpers, testutil.MariaDBImage, "--ipfs-address="+data.Get(ipfsAddrKey)) - data.Set(composeExtraKey, "--ipfs-address="+data.Get(ipfsAddrKey)) + ipfsCIDWP = pushToIPFS(helpers, testutil.WordpressImage, "--ipfs-address="+data.Labels().Get(ipfsAddrKey)) + ipfsCIDMD = pushToIPFS(helpers, testutil.MariaDBImage, "--ipfs-address="+data.Labels().Get(ipfsAddrKey)) + data.Labels().Set(composeExtraKey, "--ipfs-address="+data.Labels().Get(ipfsAddrKey)) } else { ipfsCIDWP = pushToIPFS(helpers, testutil.WordpressImage) ipfsCIDMD = pushToIPFS(helpers, testutil.MariaDBImage) } - data.Set(wordpressImageCIDKey, ipfsCIDWP) - data.Set(mariaImageCIDKey, ipfsCIDMD) + data.Labels().Set(wordpressImageCIDKey, ipfsCIDWP) + data.Labels().Set(mariaImageCIDKey, ipfsCIDMD) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -131,9 +131,9 @@ func subtestTestIPFSCompNoB(t *testing.T, stargz bool, byAddr bool) *test.Case { // they have the same cid - except for the estargz version obviously) // Deliberately electing to not remove them here so that we can parallelize and cut down the running time /* - if data.Get(mariaImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mariaImageCIDKey)) - helpers.Anyhow("rmi", "-f", data.Get(wordpressImageCIDKey)) + if data.Labels().Get(mariaImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mariaImageCIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(wordpressImageCIDKey)) } */ } @@ -141,7 +141,7 @@ func subtestTestIPFSCompNoB(t *testing.T, stargz bool, byAddr bool) *test.Case { testCase.Command = func(data test.Data, helpers test.Helpers) test.TestableCommand { safePort, err := portlock.Acquire(0) assert.NilError(helpers.T(), err) - data.Set("wordpressPort", strconv.Itoa(safePort)) + data.Labels().Set("wordpressPort", strconv.Itoa(safePort)) composeUP(data, helpers, fmt.Sprintf(` version: '3.1' @@ -175,7 +175,7 @@ services: volumes: wordpress: db: -`, data.Get(wordpressImageCIDKey), safePort, data.Get(mariaImageCIDKey)), data.Get(composeExtraKey)) +`, data.Labels().Get(wordpressImageCIDKey), safePort, data.Labels().Get(mariaImageCIDKey)), data.Labels().Get(composeExtraKey)) // FIXME: need to break down composeUP into testable commands instead // Right now, this is just a dummy placeholder return helpers.Command("info") @@ -219,7 +219,7 @@ func TestIPFSCompBuild(t *testing.T) { time.Sleep(time.Second) // Save nginx to ipfs - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.NginxAlpineImage)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.NginxAlpineImage)) const dockerComposeYAML = ` services: @@ -230,7 +230,7 @@ services: ` dockerfile := fmt.Sprintf(`FROM %s/ipfs/%s COPY index.html /usr/share/nginx/html/index.html -`, listenAddr, data.Get(mainImageCIDKey)) +`, listenAddr, data.Labels().Get(mainImageCIDKey)) comp = testutil.NewComposeDir(t, dockerComposeYAML) comp.WriteFile("Dockerfile", dockerfile) @@ -239,7 +239,7 @@ COPY index.html /usr/share/nginx/html/index.html testCase.Cleanup = func(data test.Data, helpers test.Helpers) { if ipfsServer != nil { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) ipfsServer.Signal(os.Kill) } if comp != nil { @@ -290,7 +290,7 @@ func composeUP(data test.Data, helpers test.Helpers, dockerComposeYAML string, o checkWordpress := func() error { // FIXME: see other notes on using the same port repeatedly - resp, err := nettestutil.HTTPGet("http://127.0.0.1:"+data.Get("wordpressPort"), 5, false) + resp, err := nettestutil.HTTPGet("http://127.0.0.1:"+data.Labels().Get("wordpressPort"), 5, false) if err != nil { return err } diff --git a/cmd/nerdctl/ipfs/ipfs_kubo_linux_test.go b/cmd/nerdctl/ipfs/ipfs_kubo_linux_test.go index 48068b076c8..de1dc16d239 100644 --- a/cmd/nerdctl/ipfs/ipfs_kubo_linux_test.go +++ b/cmd/nerdctl/ipfs/ipfs_kubo_linux_test.go @@ -51,7 +51,7 @@ func TestIPFSAddrWithKubo(t *testing.T) { ipfsRegistry = registry.NewKuboRegistry(data, helpers, t, nil, 0, nil) ipfsRegistry.Setup(data, helpers) ipfsAddr := fmt.Sprintf("/ip4/%s/tcp/%d", ipfsRegistry.IP, ipfsRegistry.Port) - data.Set(ipfsAddrKey, ipfsAddr) + data.Labels().Set(ipfsAddrKey, ipfsAddr) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -65,17 +65,17 @@ func TestIPFSAddrWithKubo(t *testing.T) { Description: "with default snapshotter", NoParallel: true, Setup: func(data test.Data, helpers test.Helpers) { - ipfsCID := pushToIPFS(helpers, testutil.CommonImage, fmt.Sprintf("--ipfs-address=%s", data.Get(ipfsAddrKey))) - helpers.Ensure("pull", "--quiet", "--ipfs-address", data.Get(ipfsAddrKey), "ipfs://"+ipfsCID) - data.Set(mainImageCIDKey, ipfsCID) + ipfsCID := pushToIPFS(helpers, testutil.CommonImage, fmt.Sprintf("--ipfs-address=%s", data.Labels().Get(ipfsAddrKey))) + helpers.Ensure("pull", "--quiet", "--ipfs-address", data.Labels().Get(ipfsAddrKey), "ipfs://"+ipfsCID) + data.Labels().Set(mainImageCIDKey, ipfsCID) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(mainImageCIDKey), "echo", "hello") + return helpers.Command("run", "--rm", data.Labels().Get(mainImageCIDKey), "echo", "hello") }, Expected: test.Expects(0, nil, expect.Equals("hello\n")), }, @@ -88,17 +88,17 @@ func TestIPFSAddrWithKubo(t *testing.T) { nerdtest.NerdctlNeedsFixing("https://github.com/containerd/nerdctl/issues/3475"), ), Setup: func(data test.Data, helpers test.Helpers) { - ipfsCID := pushToIPFS(helpers, testutil.CommonImage, fmt.Sprintf("--ipfs-address=%s", data.Get(ipfsAddrKey)), "--estargz") - helpers.Ensure("pull", "--quiet", "--ipfs-address", data.Get(ipfsAddrKey), "ipfs://"+ipfsCID) - data.Set(mainImageCIDKey, ipfsCID) + ipfsCID := pushToIPFS(helpers, testutil.CommonImage, fmt.Sprintf("--ipfs-address=%s", data.Labels().Get(ipfsAddrKey)), "--estargz") + helpers.Ensure("pull", "--quiet", "--ipfs-address", data.Labels().Get(ipfsAddrKey), "ipfs://"+ipfsCID) + data.Labels().Set(mainImageCIDKey, ipfsCID) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(mainImageCIDKey), "ls", "/.stargz-snapshotter") + return helpers.Command("run", "--rm", data.Labels().Get(mainImageCIDKey), "ls", "/.stargz-snapshotter") }, Expected: test.Expects(0, nil, expect.Match(regexp.MustCompile("sha256:.*[.]json[\n]"))), }, diff --git a/cmd/nerdctl/ipfs/ipfs_registry_linux_test.go b/cmd/nerdctl/ipfs/ipfs_registry_linux_test.go index dcb0f7429ed..5c044bf36af 100644 --- a/cmd/nerdctl/ipfs/ipfs_registry_linux_test.go +++ b/cmd/nerdctl/ipfs/ipfs_registry_linux_test.go @@ -89,16 +89,16 @@ func TestIPFSNerdctlRegistry(t *testing.T) { Description: "with default snapshotter", NoParallel: true, Setup: func(data test.Data, helpers test.Helpers) { - data.Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage)) - helpers.Ensure("pull", "--quiet", data.Get(ipfsImageURLKey)) + data.Labels().Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage)) + helpers.Ensure("pull", "--quiet", data.Labels().Get(ipfsImageURLKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(ipfsImageURLKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(ipfsImageURLKey)) + if data.Labels().Get(ipfsImageURLKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(ipfsImageURLKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(ipfsImageURLKey), "echo", "hello") + return helpers.Command("run", "--rm", data.Labels().Get(ipfsImageURLKey), "echo", "hello") }, Expected: test.Expects(0, nil, expect.Equals("hello\n")), }, @@ -107,16 +107,16 @@ func TestIPFSNerdctlRegistry(t *testing.T) { NoParallel: true, Require: nerdtest.Stargz, Setup: func(data test.Data, helpers test.Helpers) { - data.Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage, "--estargz")) - helpers.Ensure("pull", "--quiet", data.Get(ipfsImageURLKey)) + data.Labels().Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage, "--estargz")) + helpers.Ensure("pull", "--quiet", data.Labels().Get(ipfsImageURLKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(ipfsImageURLKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(ipfsImageURLKey)) + if data.Labels().Get(ipfsImageURLKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(ipfsImageURLKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(ipfsImageURLKey), "ls", "/.stargz-snapshotter") + return helpers.Command("run", "--rm", data.Labels().Get(ipfsImageURLKey), "ls", "/.stargz-snapshotter") }, Expected: test.Expects(0, nil, expect.Match(regexp.MustCompile("sha256:.*[.]json[\n]"))), }, @@ -126,18 +126,18 @@ func TestIPFSNerdctlRegistry(t *testing.T) { Require: nerdtest.Build, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rmi", "-f", data.Identifier("built-image")) - if data.Get(ipfsImageURLKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(ipfsImageURLKey)) + if data.Labels().Get(ipfsImageURLKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(ipfsImageURLKey)) } }, Setup: func(data test.Data, helpers test.Helpers) { - data.Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage)) + data.Labels().Set(ipfsImageURLKey, listenAddr+"/ipfs/"+pushToIPFS(helpers, testutil.CommonImage)) dockerfile := fmt.Sprintf(`FROM %s CMD ["echo", "nerdctl-build-test-string"] - `, data.Get(ipfsImageURLKey)) + `, data.Labels().Get(ipfsImageURLKey)) - buildCtx := data.TempDir() + buildCtx := data.Temp().Path() err := os.WriteFile(filepath.Join(buildCtx, "Dockerfile"), []byte(dockerfile), 0o600) assert.NilError(helpers.T(), err) diff --git a/cmd/nerdctl/ipfs/ipfs_simple_linux_test.go b/cmd/nerdctl/ipfs/ipfs_simple_linux_test.go index dda1771cadd..eb1262cc696 100644 --- a/cmd/nerdctl/ipfs/ipfs_simple_linux_test.go +++ b/cmd/nerdctl/ipfs/ipfs_simple_linux_test.go @@ -53,16 +53,16 @@ func TestIPFSSimple(t *testing.T) { Description: "with default snapshotter", NoParallel: true, Setup: func(data test.Data, helpers test.Helpers) { - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(mainImageCIDKey)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(mainImageCIDKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(mainImageCIDKey), "echo", "hello") + return helpers.Command("run", "--rm", data.Labels().Get(mainImageCIDKey), "echo", "hello") }, Expected: test.Expects(0, nil, expect.Equals("hello\n")), }, @@ -74,16 +74,16 @@ func TestIPFSSimple(t *testing.T) { nerdtest.NerdctlNeedsFixing("https://github.com/containerd/nerdctl/issues/3475"), ), Setup: func(data test.Data, helpers test.Helpers) { - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage, "--estargz")) - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(mainImageCIDKey)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage, "--estargz")) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(mainImageCIDKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(mainImageCIDKey), "ls", "/.stargz-snapshotter") + return helpers.Command("run", "--rm", data.Labels().Get(mainImageCIDKey), "ls", "/.stargz-snapshotter") }, Expected: test.Expects(0, nil, expect.Match(regexp.MustCompile("sha256:.*[.]json[\n]"))), }, @@ -91,32 +91,32 @@ func TestIPFSSimple(t *testing.T) { Description: "with commit and push", NoParallel: true, Setup: func(data test.Data, helpers test.Helpers) { - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(mainImageCIDKey)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(mainImageCIDKey)) // Run a container that does modify something, then commit and push it - helpers.Ensure("run", "--name", data.Identifier("commit-container"), data.Get(mainImageCIDKey), "sh", "-c", "--", "echo hello > /hello") + helpers.Ensure("run", "--name", data.Identifier("commit-container"), data.Labels().Get(mainImageCIDKey), "sh", "-c", "--", "echo hello > /hello") helpers.Ensure("commit", data.Identifier("commit-container"), data.Identifier("commit-image")) - data.Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("commit-image"))) + data.Labels().Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("commit-image"))) // Clean-up helpers.Ensure("rm", data.Identifier("commit-container")) helpers.Ensure("rmi", data.Identifier("commit-image")) // Pull back the committed image - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(transformedImageCIDKey)) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(transformedImageCIDKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier("commit-container")) helpers.Anyhow("rmi", "-f", data.Identifier("commit-image")) - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) - helpers.Anyhow("rmi", "-f", data.Get(transformedImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(transformedImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(transformedImageCIDKey), "cat", "/hello") + return helpers.Command("run", "--rm", data.Labels().Get(transformedImageCIDKey), "cat", "/hello") }, Expected: test.Expects(0, nil, expect.Equals("hello\n")), @@ -129,32 +129,32 @@ func TestIPFSSimple(t *testing.T) { nerdtest.NerdctlNeedsFixing("https://github.com/containerd/nerdctl/issues/3475"), ), Setup: func(data test.Data, helpers test.Helpers) { - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage, "--estargz")) - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(mainImageCIDKey)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage, "--estargz")) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(mainImageCIDKey)) // Run a container that does modify something, then commit and push it - helpers.Ensure("run", "--name", data.Identifier("commit-container"), data.Get(mainImageCIDKey), "sh", "-c", "--", "echo hello > /hello") + helpers.Ensure("run", "--name", data.Identifier("commit-container"), data.Labels().Get(mainImageCIDKey), "sh", "-c", "--", "echo hello > /hello") helpers.Ensure("commit", data.Identifier("commit-container"), data.Identifier("commit-image")) - data.Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("commit-image"))) + data.Labels().Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("commit-image"))) // Clean-up helpers.Ensure("rm", data.Identifier("commit-container")) helpers.Ensure("rmi", data.Identifier("commit-image")) // Pull back the image - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(transformedImageCIDKey)) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(transformedImageCIDKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier("commit-container")) helpers.Anyhow("rmi", "-f", data.Identifier("commit-image")) - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) - helpers.Anyhow("rmi", "-f", data.Get(transformedImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(transformedImageCIDKey)) } }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--rm", data.Get(transformedImageCIDKey), "sh", "-c", "--", "cat /hello && ls /.stargz-snapshotter") + return helpers.Command("run", "--rm", data.Labels().Get(transformedImageCIDKey), "sh", "-c", "--", "cat /hello && ls /.stargz-snapshotter") }, Expected: test.Expects(0, nil, expect.Match(regexp.MustCompile("hello[\n]sha256:.*[.]json[\n]"))), @@ -164,18 +164,18 @@ func TestIPFSSimple(t *testing.T) { NoParallel: true, Require: require.Binary("openssl"), Setup: func(data test.Data, helpers test.Helpers) { - data.Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) - helpers.Ensure("pull", "--quiet", "ipfs://"+data.Get(mainImageCIDKey)) + data.Labels().Set(mainImageCIDKey, pushToIPFS(helpers, testutil.CommonImage)) + helpers.Ensure("pull", "--quiet", "ipfs://"+data.Labels().Get(mainImageCIDKey)) // Prep a key pair keyPair := testhelpers.NewJWEKeyPair(t) // FIXME: this will only cleanup when the group is done, not right, but it works t.Cleanup(keyPair.Cleanup) - data.Set("pub", keyPair.Pub) - data.Set("prv", keyPair.Prv) + data.Labels().Set("pub", keyPair.Pub) + data.Labels().Set("prv", keyPair.Prv) // Encrypt the image, and verify it is encrypted - helpers.Ensure("image", "encrypt", "--recipient=jwe:"+keyPair.Pub, data.Get(mainImageCIDKey), data.Identifier("encrypted")) + helpers.Ensure("image", "encrypt", "--recipient=jwe:"+keyPair.Pub, data.Labels().Get(mainImageCIDKey), data.Identifier("encrypted")) cmd := helpers.Command("image", "inspect", "--mode=native", "--format={{len .Index.Manifests}}", data.Identifier("encrypted")) cmd.Run(&test.Expected{ Output: expect.Equals("1\n"), @@ -186,19 +186,19 @@ func TestIPFSSimple(t *testing.T) { }) // Push the encrypted image and save the CID - data.Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("encrypted"))) + data.Labels().Set(transformedImageCIDKey, pushToIPFS(helpers, data.Identifier("encrypted"))) // Remove both images locally - helpers.Ensure("rmi", "-f", data.Get(mainImageCIDKey)) - helpers.Ensure("rmi", "-f", data.Get(transformedImageCIDKey)) + helpers.Ensure("rmi", "-f", data.Labels().Get(mainImageCIDKey)) + helpers.Ensure("rmi", "-f", data.Labels().Get(transformedImageCIDKey)) // Pull back without unpacking - helpers.Ensure("pull", "--quiet", "--unpack=false", "ipfs://"+data.Get(transformedImageCIDKey)) + helpers.Ensure("pull", "--quiet", "--unpack=false", "ipfs://"+data.Labels().Get(transformedImageCIDKey)) }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get(mainImageCIDKey) != "" { - helpers.Anyhow("rmi", "-f", data.Get(mainImageCIDKey)) - helpers.Anyhow("rmi", "-f", data.Get(transformedImageCIDKey)) + if data.Labels().Get(mainImageCIDKey) != "" { + helpers.Anyhow("rmi", "-f", data.Labels().Get(mainImageCIDKey)) + helpers.Anyhow("rmi", "-f", data.Labels().Get(transformedImageCIDKey)) } }, SubTests: []*test.Case{ @@ -208,7 +208,7 @@ func TestIPFSSimple(t *testing.T) { helpers.Anyhow("rm", "-f", data.Identifier("decrypted")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("image", "decrypt", "--key="+data.Get("pub"), data.Get(transformedImageCIDKey), data.Identifier("decrypted")) + return helpers.Command("image", "decrypt", "--key="+data.Labels().Get("pub"), data.Labels().Get(transformedImageCIDKey), data.Identifier("decrypted")) }, Expected: test.Expects(1, nil, nil), }, @@ -218,7 +218,7 @@ func TestIPFSSimple(t *testing.T) { helpers.Anyhow("rm", "-f", data.Identifier("decrypted")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("image", "decrypt", "--key="+data.Get("prv"), data.Get(transformedImageCIDKey), data.Identifier("decrypted")) + return helpers.Command("image", "decrypt", "--key="+data.Labels().Get("prv"), data.Labels().Get(transformedImageCIDKey), data.Identifier("decrypted")) }, Expected: test.Expects(0, nil, nil), }, diff --git a/cmd/nerdctl/main_test_test.go b/cmd/nerdctl/main_test_test.go index ae9acc0f7f6..4a06ea3667f 100644 --- a/cmd/nerdctl/main_test_test.go +++ b/cmd/nerdctl/main_test_test.go @@ -72,29 +72,29 @@ func TestTest(t *testing.T) { }, { Description: "data propagation", - Data: test.WithData("status", "uninitialized"), + Data: test.WithLabels(map[string]string{"status": "uninitialized"}), Setup: func(data test.Data, helpers test.Helpers) { - data.Set("status", data.Get("status")+"-setup") + data.Labels().Set("status", data.Labels().Get("status")+"-setup") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Custom("printf", data.Get("status")) - data.Set("status", data.Get("status")+"-command") + cmd := helpers.Custom("printf", data.Labels().Get("status")) + data.Labels().Set("status", data.Labels().Get("status")+"-command") return cmd }, Cleanup: func(data test.Data, helpers test.Helpers) { - if data.Get("status") == "uninitialized" { + if data.Labels().Get("status") == "uninitialized" { return } - if data.Get("status") != "uninitialized-setup-command" { - log.Fatalf("unexpected status label %q", data.Get("status")) + if data.Labels().Get("status") != "uninitialized-setup-command" { + log.Fatalf("unexpected status label %q", data.Labels().Get("status")) } - data.Set("status", data.Get("status")+"-cleanup") + data.Labels().Set("status", data.Labels().Get("status")+"-cleanup") }, SubTests: []*test.Case{ { Description: "Subtest data propagation", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Custom("printf", data.Get("status")) + return helpers.Custom("printf", data.Labels().Get("status")) }, Expected: test.Expects(0, nil, expect.Equals("uninitialized-setup-command")), }, diff --git a/cmd/nerdctl/network/network_create_linux_test.go b/cmd/nerdctl/network/network_create_linux_test.go index 418f07fde74..5dd82655390 100644 --- a/cmd/nerdctl/network/network_create_linux_test.go +++ b/cmd/nerdctl/network/network_create_linux_test.go @@ -42,7 +42,7 @@ func TestNetworkCreate(t *testing.T) { helpers.Ensure("network", "create", identifier) netw := nerdtest.InspectNetwork(helpers, identifier) assert.Equal(t, len(netw.IPAM.Config), 1) - data.Set("subnet", netw.IPAM.Config[0].Subnet) + data.Labels().Set("subnet", netw.IPAM.Config[0].Subnet) helpers.Ensure("network", "create", data.Identifier("1")) }, @@ -51,7 +51,7 @@ func TestNetworkCreate(t *testing.T) { helpers.Anyhow("network", "rm", data.Identifier("1")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - data.Set("container2", helpers.Capture("run", "--rm", "--net", data.Identifier("1"), testutil.CommonImage, "ip", "route")) + data.Labels().Set("container2", helpers.Capture("run", "--rm", "--net", data.Identifier("1"), testutil.CommonImage, "ip", "route")) return helpers.Command("run", "--rm", "--net", data.Identifier(), testutil.CommonImage, "ip", "route") }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { @@ -59,8 +59,8 @@ func TestNetworkCreate(t *testing.T) { ExitCode: 0, Errors: nil, Output: func(stdout string, info string, t *testing.T) { - assert.Assert(t, strings.Contains(stdout, data.Get("subnet")), info) - assert.Assert(t, !strings.Contains(data.Get("container2"), data.Get("subnet")), info) + assert.Assert(t, strings.Contains(stdout, data.Labels().Get("subnet")), info) + assert.Assert(t, !strings.Contains(data.Labels().Get("container2"), data.Labels().Get("subnet")), info) }, } }, @@ -83,7 +83,7 @@ func TestNetworkCreate(t *testing.T) { Require: nerdtest.OnlyIPv6, Setup: func(data test.Data, helpers test.Helpers) { subnetStr := "2001:db8:8::/64" - data.Set("subnetStr", subnetStr) + data.Labels().Set("subnetStr", subnetStr) _, _, err := net.ParseCIDR(subnetStr) assert.Assert(t, err == nil) @@ -99,7 +99,7 @@ func TestNetworkCreate(t *testing.T) { return &test.Expected{ ExitCode: 0, Output: func(stdout string, info string, t *testing.T) { - _, subnet, _ := net.ParseCIDR(data.Get("subnetStr")) + _, subnet, _ := net.ParseCIDR(data.Labels().Get("subnetStr")) ip := ipv6helper.FindIPv6(stdout) assert.Assert(t, subnet.Contains(ip), info) }, diff --git a/cmd/nerdctl/network/network_inspect_test.go b/cmd/nerdctl/network/network_inspect_test.go index cb89f25f2d4..d7ce389bb91 100644 --- a/cmd/nerdctl/network/network_inspect_test.go +++ b/cmd/nerdctl/network/network_inspect_test.go @@ -43,7 +43,7 @@ func TestNetworkInspect(t *testing.T) { testCase.Setup = func(data test.Data, helpers test.Helpers) { helpers.Ensure("network", "create", data.Identifier("basenet")) - data.Set("basenet", data.Identifier("basenet")) + data.Labels().Set("basenet", data.Identifier("basenet")) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -132,7 +132,7 @@ func TestNetworkInspect(t *testing.T) { Description: "match exact id", // See notes below Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Get("basenet"), "--format", "{{ .Id }}")) + id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Labels().Get("basenet"), "--format", "{{ .Id }}")) return helpers.Command("network", "inspect", id) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { @@ -142,7 +142,7 @@ func TestNetworkInspect(t *testing.T) { err := json.Unmarshal([]byte(stdout), &dc) assert.NilError(t, err, "Unable to unmarshal output\n"+info) assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - assert.Equal(t, dc[0].Name, data.Get("basenet")) + assert.Equal(t, dc[0].Name, data.Labels().Get("basenet")) }, } }, @@ -153,7 +153,7 @@ func TestNetworkInspect(t *testing.T) { // This is bizarre, as it is working in the match exact id test - and there does not seem to be a particular reason for that Require: require.Not(require.Windows), Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Get("basenet"), "--format", "{{ .Id }}")) + id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Labels().Get("basenet"), "--format", "{{ .Id }}")) return helpers.Command("network", "inspect", id[0:25]) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { @@ -163,7 +163,7 @@ func TestNetworkInspect(t *testing.T) { err := json.Unmarshal([]byte(stdout), &dc) assert.NilError(t, err, "Unable to unmarshal output\n"+info) assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - assert.Equal(t, dc[0].Name, data.Get("basenet")) + assert.Equal(t, dc[0].Name, data.Labels().Get("basenet")) }, } }, @@ -174,15 +174,15 @@ func TestNetworkInspect(t *testing.T) { // This is bizarre, as it is working in the match exact id test - and there does not seem to be a particular reason for that Require: require.Not(require.Windows), Setup: func(data test.Data, helpers test.Helpers) { - id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Get("basenet"), "--format", "{{ .Id }}")) + id := strings.TrimSpace(helpers.Capture("network", "inspect", data.Labels().Get("basenet"), "--format", "{{ .Id }}")) helpers.Ensure("network", "create", id[0:12]) - data.Set("netname", id[0:12]) + data.Labels().Set("netname", id[0:12]) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("network", "remove", data.Get("netname")) + helpers.Anyhow("network", "remove", data.Labels().Get("netname")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("network", "inspect", data.Get("netname")) + return helpers.Command("network", "inspect", data.Labels().Get("netname")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -191,7 +191,7 @@ func TestNetworkInspect(t *testing.T) { err := json.Unmarshal([]byte(stdout), &dc) assert.NilError(t, err, "Unable to unmarshal output\n"+info) assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - assert.Equal(t, dc[0].Name, data.Get("netname")) + assert.Equal(t, dc[0].Name, data.Labels().Get("netname")) }, } }, diff --git a/cmd/nerdctl/network/network_list_linux_test.go b/cmd/nerdctl/network/network_list_linux_test.go index 96f35dedf2e..3bf6f9e912f 100644 --- a/cmd/nerdctl/network/network_list_linux_test.go +++ b/cmd/nerdctl/network/network_list_linux_test.go @@ -31,12 +31,12 @@ func TestNetworkLsFilter(t *testing.T) { testCase := nerdtest.Setup() testCase.Setup = func(data test.Data, helpers test.Helpers) { - data.Set("identifier", data.Identifier()) - data.Set("label", "mylabel=label-1") - data.Set("net1", data.Identifier("1")) - data.Set("net2", data.Identifier("2")) - data.Set("netID1", helpers.Capture("network", "create", "--label="+data.Get("label"), data.Get("net1"))) - data.Set("netID2", helpers.Capture("network", "create", data.Get("net2"))) + data.Labels().Set("identifier", data.Identifier()) + data.Labels().Set("label", "mylabel=label-1") + data.Labels().Set("net1", data.Identifier("1")) + data.Labels().Set("net2", data.Identifier("2")) + data.Labels().Set("netID1", helpers.Capture("network", "create", "--label="+data.Labels().Get("label"), data.Labels().Get("net1"))) + data.Labels().Set("netID2", helpers.Capture("network", "create", data.Labels().Get("net2"))) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -48,7 +48,7 @@ func TestNetworkLsFilter(t *testing.T) { { Description: "filter label", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("network", "ls", "--quiet", "--filter", "label="+data.Get("label")) + return helpers.Command("network", "ls", "--quiet", "--filter", "label="+data.Labels().Get("label")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -56,7 +56,7 @@ func TestNetworkLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 1, info) netNames := map[string]struct{}{ - data.Get("netID1")[:12]: {}, + data.Labels().Get("netID1")[:12]: {}, } for _, name := range lines { @@ -70,7 +70,7 @@ func TestNetworkLsFilter(t *testing.T) { { Description: "filter name", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("network", "ls", "--quiet", "--filter", "name="+data.Get("net2")) + return helpers.Command("network", "ls", "--quiet", "--filter", "name="+data.Labels().Get("net2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -78,7 +78,7 @@ func TestNetworkLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 1, info) netNames := map[string]struct{}{ - data.Get("netID2")[:12]: {}, + data.Labels().Get("netID2")[:12]: {}, } for _, name := range lines { diff --git a/cmd/nerdctl/network/network_remove_linux_test.go b/cmd/nerdctl/network/network_remove_linux_test.go index 48906cbad08..7a86ec37962 100644 --- a/cmd/nerdctl/network/network_remove_linux_test.go +++ b/cmd/nerdctl/network/network_remove_linux_test.go @@ -40,11 +40,11 @@ func TestNetworkRemove(t *testing.T) { Setup: func(data test.Data, helpers test.Helpers) { identifier := data.Identifier() helpers.Ensure("network", "create", identifier) - data.Set("netID", nerdtest.InspectNetwork(helpers, identifier).ID) + data.Labels().Set("netID", nerdtest.InspectNetwork(helpers, identifier).ID) helpers.Ensure("run", "--rm", "--net", identifier, "--name", identifier, testutil.CommonImage) // Verity the network is here - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) - assert.NilError(t, err, "failed to find network br-"+data.Get("netID")[:12], "%v") + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) + assert.NilError(t, err, "failed to find network br-"+data.Labels().Get("netID")[:12], "%v") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { return helpers.Command("network", "rm", data.Identifier()) @@ -56,7 +56,7 @@ func TestNetworkRemove(t *testing.T) { return &test.Expected{ ExitCode: 0, Output: func(stdout string, info string, t *testing.T) { - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) assert.Error(t, err, "Link not found", info) }, } @@ -81,14 +81,14 @@ func TestNetworkRemove(t *testing.T) { Description: "Network remove by id", Setup: func(data test.Data, helpers test.Helpers) { helpers.Ensure("network", "create", data.Identifier()) - data.Set("netID", nerdtest.InspectNetwork(helpers, data.Identifier()).ID) + data.Labels().Set("netID", nerdtest.InspectNetwork(helpers, data.Identifier()).ID) helpers.Ensure("run", "--rm", "--net", data.Identifier(), "--name", data.Identifier(), testutil.CommonImage) // Verity the network is here - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) - assert.NilError(t, err, "failed to find network br-"+data.Get("netID")[:12], "%v") + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) + assert.NilError(t, err, "failed to find network br-"+data.Labels().Get("netID")[:12], "%v") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("network", "rm", data.Get("netID")) + return helpers.Command("network", "rm", data.Labels().Get("netID")) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("network", "rm", data.Identifier()) @@ -97,7 +97,7 @@ func TestNetworkRemove(t *testing.T) { return &test.Expected{ ExitCode: 0, Output: func(stdout string, info string, t *testing.T) { - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) assert.Error(t, err, "Link not found", info) }, } @@ -107,14 +107,14 @@ func TestNetworkRemove(t *testing.T) { Description: "Network remove by short id", Setup: func(data test.Data, helpers test.Helpers) { helpers.Ensure("network", "create", data.Identifier()) - data.Set("netID", nerdtest.InspectNetwork(helpers, data.Identifier()).ID) + data.Labels().Set("netID", nerdtest.InspectNetwork(helpers, data.Identifier()).ID) helpers.Ensure("run", "--rm", "--net", data.Identifier(), "--name", data.Identifier(), testutil.CommonImage) // Verity the network is here - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) - assert.NilError(t, err, "failed to find network br-"+data.Get("netID")[:12], "%v") + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) + assert.NilError(t, err, "failed to find network br-"+data.Labels().Get("netID")[:12], "%v") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("network", "rm", data.Get("netID")[:12]) + return helpers.Command("network", "rm", data.Labels().Get("netID")[:12]) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("network", "rm", data.Identifier()) @@ -123,7 +123,7 @@ func TestNetworkRemove(t *testing.T) { return &test.Expected{ ExitCode: 0, Output: func(stdout string, info string, t *testing.T) { - _, err := netlink.LinkByName("br-" + data.Get("netID")[:12]) + _, err := netlink.LinkByName("br-" + data.Labels().Get("netID")[:12]) assert.Error(t, err, "Link not found", info) }, } diff --git a/cmd/nerdctl/system/system_events_linux_test.go b/cmd/nerdctl/system/system_events_linux_test.go index bcf01bd0f19..37310bf9a7c 100644 --- a/cmd/nerdctl/system/system_events_linux_test.go +++ b/cmd/nerdctl/system/system_events_linux_test.go @@ -29,7 +29,7 @@ import ( ) func testEventFilterExecutor(data test.Data, helpers test.Helpers) test.TestableCommand { - cmd := helpers.Command("events", "--filter", data.Get("filter"), "--format", "json") + cmd := helpers.Command("events", "--filter", data.Labels().Get("filter"), "--format", "json") // 3 seconds is too short on slow rig (EL8) cmd.WithTimeout(10 * time.Second) cmd.Background() @@ -48,11 +48,13 @@ func TestEventFilters(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: expect.ExitCodeTimeout, - Output: expect.Contains(data.Get("output")), + Output: expect.Contains(data.Labels().Get("output")), } }, - Data: test.WithData("filter", "event=START"). - Set("output", "\"Status\":\"start\""), + Data: test.WithLabels(map[string]string{ + "filter": "event=START", + "output": "\"Status\":\"start\"", + }), }, { Description: "StartEventFilter", @@ -60,11 +62,13 @@ func TestEventFilters(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: expect.ExitCodeTimeout, - Output: expect.Contains(data.Get("output")), + Output: expect.Contains(data.Labels().Get("output")), } }, - Data: test.WithData("filter", "event=start"). - Set("output", "tatus\":\"start\""), + Data: test.WithLabels(map[string]string{ + "filter": "event=start", + "output": "tatus\":\"start\"", + }), }, { Description: "UnsupportedEventFilter", @@ -73,11 +77,13 @@ func TestEventFilters(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: expect.ExitCodeTimeout, - Output: expect.Contains(data.Get("output")), + Output: expect.Contains(data.Labels().Get("output")), } }, - Data: test.WithData("filter", "event=unknown"). - Set("output", "\"Status\":\"unknown\""), + Data: test.WithLabels(map[string]string{ + "filter": "event=unknown", + "output": "\"Status\":\"unknown\"", + }), }, { Description: "StatusFilter", @@ -85,11 +91,13 @@ func TestEventFilters(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: expect.ExitCodeTimeout, - Output: expect.Contains(data.Get("output")), + Output: expect.Contains(data.Labels().Get("output")), } }, - Data: test.WithData("filter", "status=start"). - Set("output", "tatus\":\"start\""), + Data: test.WithLabels(map[string]string{ + "filter": "status=start", + "output": "tatus\":\"start\"", + }), }, { Description: "UnsupportedStatusFilter", @@ -98,11 +106,13 @@ func TestEventFilters(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: expect.ExitCodeTimeout, - Output: expect.Contains(data.Get("output")), + Output: expect.Contains(data.Labels().Get("output")), } }, - Data: test.WithData("filter", "status=unknown"). - Set("output", "\"Status\":\"unknown\""), + Data: test.WithLabels(map[string]string{ + "filter": "status=unknown", + "output": "\"Status\":\"unknown\"", + }), }, } diff --git a/cmd/nerdctl/system/system_prune_linux_test.go b/cmd/nerdctl/system/system_prune_linux_test.go index 45a0b896d01..70a4a9df651 100644 --- a/cmd/nerdctl/system/system_prune_linux_test.go +++ b/cmd/nerdctl/system/system_prune_linux_test.go @@ -48,12 +48,12 @@ func TestSystemPrune(t *testing.T) { helpers.Ensure("run", "-v", fmt.Sprintf("%s:/volume", data.Identifier()), "--net", data.Identifier(), "--name", data.Identifier(), testutil.CommonImage) - data.Set("anonIdentifier", anonIdentifier) + data.Labels().Set("anonIdentifier", anonIdentifier) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("network", "rm", data.Identifier()) helpers.Anyhow("volume", "rm", data.Identifier()) - helpers.Anyhow("volume", "rm", data.Get("anonIdentifier")) + helpers.Anyhow("volume", "rm", data.Labels().Get("anonIdentifier")) helpers.Anyhow("rm", "-f", data.Identifier()) }, Command: test.Command("system", "prune", "-f", "--volumes", "--all"), @@ -66,7 +66,7 @@ func TestSystemPrune(t *testing.T) { images := helpers.Capture("images") containers := helpers.Capture("ps", "-a") assert.Assert(t, strings.Contains(volumes, data.Identifier()), volumes) - assert.Assert(t, !strings.Contains(volumes, data.Get("anonIdentifier")), volumes) + assert.Assert(t, !strings.Contains(volumes, data.Labels().Get("anonIdentifier")), volumes) assert.Assert(t, !strings.Contains(containers, data.Identifier()), containers) assert.Assert(t, !strings.Contains(networks, data.Identifier()), networks) assert.Assert(t, !strings.Contains(images, testutil.CommonImage), images) diff --git a/cmd/nerdctl/volume/volume_inspect_test.go b/cmd/nerdctl/volume/volume_inspect_test.go index 86d070065e4..af2e7938884 100644 --- a/cmd/nerdctl/volume/volume_inspect_test.go +++ b/cmd/nerdctl/volume/volume_inspect_test.go @@ -65,8 +65,8 @@ func TestVolumeInspect(t *testing.T) { vol := nerdtest.InspectVolume(helpers, data.Identifier("first")) err := createFileWithSize(vol.Mountpoint, size) assert.NilError(t, err, "File creation failed") - data.Set("vol1", data.Identifier("first")) - data.Set("vol2", data.Identifier("second")) + data.Labels().Set("vol1", data.Identifier("first")) + data.Labels().Set("vol2", data.Identifier("second")) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { @@ -93,15 +93,15 @@ func TestVolumeInspect(t *testing.T) { { Description: "success", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", data.Get("vol1")) + return helpers.Command("volume", "inspect", data.Labels().Get("vol1")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("vol1")), + expect.Contains(data.Labels().Get("vol1")), expect.JSON([]native.Volume{}, func(dc []native.Volume, info string, t tig.T) { assert.Assert(t, len(dc) == 1, fmt.Sprintf("one result, not %d", len(dc))+info) - assert.Assert(t, dc[0].Name == data.Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Get("vol1"), dc[0].Name)+info) + assert.Assert(t, dc[0].Name == data.Labels().Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Labels().Get("vol1"), dc[0].Name)+info) assert.Assert(t, dc[0].Labels == nil, fmt.Sprintf("expected labels to be nil and were %v", dc[0].Labels)+info) }), ), @@ -111,12 +111,12 @@ func TestVolumeInspect(t *testing.T) { { Description: "inspect labels", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", data.Get("vol2")) + return helpers.Command("volume", "inspect", data.Labels().Get("vol2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("vol2")), + expect.Contains(data.Labels().Get("vol2")), expect.JSON([]native.Volume{}, func(dc []native.Volume, info string, t tig.T) { labels := *dc[0].Labels assert.Assert(t, len(labels) == 2, fmt.Sprintf("two results, not %d", len(labels))) @@ -131,12 +131,12 @@ func TestVolumeInspect(t *testing.T) { Description: "inspect size", Require: require.Not(nerdtest.Docker), Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", "--size", data.Get("vol1")) + return helpers.Command("volume", "inspect", "--size", data.Labels().Get("vol1")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("vol1")), + expect.Contains(data.Labels().Get("vol1")), expect.JSON([]native.Volume{}, func(dc []native.Volume, info string, t tig.T) { assert.Assert(t, dc[0].Size == size, fmt.Sprintf("expected size to be %d (was %d)", size, dc[0].Size)) }), @@ -147,17 +147,17 @@ func TestVolumeInspect(t *testing.T) { { Description: "multi success", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", data.Get("vol1"), data.Get("vol2")) + return helpers.Command("volume", "inspect", data.Labels().Get("vol1"), data.Labels().Get("vol2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.Contains(data.Get("vol1")), - expect.Contains(data.Get("vol2")), + expect.Contains(data.Labels().Get("vol1")), + expect.Contains(data.Labels().Get("vol2")), expect.JSON([]native.Volume{}, func(dc []native.Volume, info string, t tig.T) { assert.Assert(t, len(dc) == 2, fmt.Sprintf("two results, not %d", len(dc))) - assert.Assert(t, dc[0].Name == data.Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Get("vol1"), dc[0].Name)) - assert.Assert(t, dc[1].Name == data.Get("vol2"), fmt.Sprintf("expected name to be %q (was %q)", data.Get("vol2"), dc[1].Name)) + assert.Assert(t, dc[0].Name == data.Labels().Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Labels().Get("vol1"), dc[0].Name)) + assert.Assert(t, dc[1].Name == data.Labels().Get("vol2"), fmt.Sprintf("expected name to be %q (was %q)", data.Labels().Get("vol2"), dc[1].Name)) }), ), } @@ -166,17 +166,17 @@ func TestVolumeInspect(t *testing.T) { { Description: "part success multi", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", "invalid∞", "nonexistent", data.Get("vol1")) + return helpers.Command("volume", "inspect", "invalid∞", "nonexistent", data.Labels().Get("vol1")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ ExitCode: 1, Errors: []error{errdefs.ErrNotFound, errdefs.ErrInvalidArgument}, Output: expect.All( - expect.Contains(data.Get("vol1")), + expect.Contains(data.Labels().Get("vol1")), expect.JSON([]native.Volume{}, func(dc []native.Volume, info string, t tig.T) { assert.Assert(t, len(dc) == 1, fmt.Sprintf("one result, not %d", len(dc))) - assert.Assert(t, dc[0].Name == data.Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Get("vol1"), dc[0].Name)) + assert.Assert(t, dc[0].Name == data.Labels().Get("vol1"), fmt.Sprintf("expected name to be %q (was %q)", data.Labels().Get("vol1"), dc[0].Name)) }), ), } diff --git a/cmd/nerdctl/volume/volume_list_test.go b/cmd/nerdctl/volume/volume_list_test.go index 0610925df32..d666595abc6 100644 --- a/cmd/nerdctl/volume/volume_list_test.go +++ b/cmd/nerdctl/volume/volume_list_test.go @@ -122,22 +122,22 @@ func TestVolumeLsFilter(t *testing.T) { err = createFileWithSize(nerdtest.InspectVolume(helpers, vol4).Mountpoint, 1024000) assert.NilError(t, err, "File creation failed") - data.Set("vol1", vol1) - data.Set("vol2", vol2) - data.Set("vol3", vol3) - data.Set("vol4", vol4) - data.Set("mainlabel", "mylabel") - data.Set("label1", label1) - data.Set("label2", label2) - data.Set("label3", label3) - data.Set("label4", label4) + data.Labels().Set("vol1", vol1) + data.Labels().Set("vol2", vol2) + data.Labels().Set("vol3", vol3) + data.Labels().Set("vol4", vol4) + data.Labels().Set("mainlabel", "mylabel") + data.Labels().Set("label1", label1) + data.Labels().Set("label2", label2) + data.Labels().Set("label3", label3) + data.Labels().Set("label4", label4) } testCase.Cleanup = func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("volume", "rm", "-f", data.Get("vol1")) - helpers.Anyhow("volume", "rm", "-f", data.Get("vol2")) - helpers.Anyhow("volume", "rm", "-f", data.Get("vol3")) - helpers.Anyhow("volume", "rm", "-f", data.Get("vol4")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("vol1")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("vol2")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("vol3")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("vol4")) } testCase.SubTests = []*test.Case{ { @@ -149,10 +149,10 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 4, "expected at least 4 lines"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, - data.Get("vol2"): {}, - data.Get("vol3"): {}, - data.Get("vol4"): {}, + data.Labels().Get("vol1"): {}, + data.Labels().Get("vol2"): {}, + data.Labels().Get("vol3"): {}, + data.Labels().Get("vol4"): {}, } var numMatches = 0 for _, name := range lines { @@ -170,7 +170,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving label=mainlabel", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Get("mainlabel")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Labels().Get("mainlabel")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -178,9 +178,9 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 3, "expected at least 3 lines"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, - data.Get("vol2"): {}, - data.Get("vol3"): {}, + data.Labels().Get("vol1"): {}, + data.Labels().Get("vol2"): {}, + data.Labels().Get("vol3"): {}, } for _, name := range lines { _, ok := volNames[name] @@ -193,7 +193,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving label=mainlabel=label2", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Get("label2")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Labels().Get("label2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -201,7 +201,7 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 1, "expected at least 1 lines"+info) volNames := map[string]struct{}{ - data.Get("vol2"): {}, + data.Labels().Get("vol2"): {}, } for _, name := range lines { _, ok := volNames[name] @@ -214,7 +214,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving label=mainlabel=", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Get("mainlabel")+"=") + return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Labels().Get("mainlabel")+"=") }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -227,7 +227,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving label=mainlabel=label1 and label=mainlabel=label2", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Get("label1"), "--filter", "label="+data.Get("label2")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Labels().Get("label1"), "--filter", "label="+data.Labels().Get("label2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -240,7 +240,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving label=mainlabel and label=grouplabel=label4", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Get("mainlabel"), "--filter", "label="+data.Get("label4")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "label="+data.Labels().Get("mainlabel"), "--filter", "label="+data.Labels().Get("label4")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -248,8 +248,8 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 2, "expected at least 2 lines"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, - data.Get("vol2"): {}, + data.Labels().Get("vol1"): {}, + data.Labels().Get("vol2"): {}, } for _, name := range lines { _, ok := volNames[name] @@ -262,7 +262,7 @@ func TestVolumeLsFilter(t *testing.T) { { Description: "Retrieving name=volume1", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "name="+data.Get("vol1")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "name="+data.Labels().Get("vol1")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -270,7 +270,7 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 1, "expected at least 1 line"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, + data.Labels().Get("vol1"): {}, } for _, name := range lines { _, ok := volNames[name] @@ -285,7 +285,7 @@ func TestVolumeLsFilter(t *testing.T) { // Nerdctl filter behavior is broken Require: nerdtest.NerdctlNeedsFixing("https://github.com/containerd/nerdctl/issues/3452"), Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "ls", "--quiet", "--filter", "name="+data.Get("vol1"), "--filter", "name="+data.Get("vol2")) + return helpers.Command("volume", "ls", "--quiet", "--filter", "name="+data.Labels().Get("vol1"), "--filter", "name="+data.Labels().Get("vol2")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -293,8 +293,8 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 2, "expected at least 2 lines"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, - data.Get("vol2"): {}, + data.Labels().Get("vol1"): {}, + data.Labels().Get("vol2"): {}, } for _, name := range lines { _, ok := volNames[name] @@ -316,8 +316,8 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 3, "expected at least 3 lines"+info) volNames := map[string]struct{}{ - data.Get("vol2"): {}, - data.Get("vol4"): {}, + data.Labels().Get("vol2"): {}, + data.Labels().Get("vol4"): {}, } var tab = tabutil.NewReader("VOLUME NAME\tDIRECTORY\tSIZE") var err = tab.ParseHeader(lines[0]) @@ -347,8 +347,8 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 3, "expected at least 3 lines"+info) volNames := map[string]struct{}{ - data.Get("vol2"): {}, - data.Get("vol4"): {}, + data.Labels().Get("vol2"): {}, + data.Labels().Get("vol4"): {}, } var tab = tabutil.NewReader("VOLUME NAME\tDIRECTORY\tSIZE") var err = tab.ParseHeader(lines[0]) @@ -378,8 +378,8 @@ func TestVolumeLsFilter(t *testing.T) { var lines = strings.Split(strings.TrimSpace(stdout), "\n") assert.Assert(t, len(lines) >= 3, "expected at least 3 lines"+info) volNames := map[string]struct{}{ - data.Get("vol1"): {}, - data.Get("vol3"): {}, + data.Labels().Get("vol1"): {}, + data.Labels().Get("vol3"): {}, } var tab = tabutil.NewReader("VOLUME NAME\tDIRECTORY\tSIZE") var err = tab.ParseHeader(lines[0]) diff --git a/cmd/nerdctl/volume/volume_namespace_test.go b/cmd/nerdctl/volume/volume_namespace_test.go index a4b351d9286..341d2d37204 100644 --- a/cmd/nerdctl/volume/volume_namespace_test.go +++ b/cmd/nerdctl/volume/volume_namespace_test.go @@ -35,14 +35,14 @@ func TestVolumeNamespace(t *testing.T) { // Create a volume in a different namespace testCase.Setup = func(data test.Data, helpers test.Helpers) { - data.Set("root_namespace", data.Identifier()) - data.Set("root_volume", data.Identifier()) + data.Labels().Set("root_namespace", data.Identifier()) + data.Labels().Set("root_volume", data.Identifier()) helpers.Ensure("--namespace", data.Identifier(), "volume", "create", data.Identifier()) } // Cleanup once done testCase.Cleanup = func(data test.Data, helpers test.Helpers) { - if data.Get("root_namespace") != "" { + if data.Labels().Get("root_namespace") != "" { helpers.Anyhow("--namespace", data.Identifier(), "volume", "remove", data.Identifier()) helpers.Anyhow("namespace", "remove", data.Identifier()) } @@ -52,7 +52,7 @@ func TestVolumeNamespace(t *testing.T) { { Description: "inspect another namespace volume should fail", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "inspect", data.Get("root_volume")) + return helpers.Command("volume", "inspect", data.Labels().Get("root_volume")) }, Expected: test.Expects(1, []error{ errdefs.ErrNotFound, @@ -61,7 +61,7 @@ func TestVolumeNamespace(t *testing.T) { { Description: "removing another namespace volume should fail", Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "remove", data.Get("root_volume")) + return helpers.Command("volume", "remove", data.Labels().Get("root_volume")) }, Expected: test.Expects(1, []error{ errdefs.ErrNotFound, @@ -75,9 +75,9 @@ func TestVolumeNamespace(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.DoesNotContain(data.Get("root_volume")), + expect.DoesNotContain(data.Labels().Get("root_volume")), func(stdout string, info string, t *testing.T) { - helpers.Ensure("--namespace", data.Get("root_namespace"), "volume", "inspect", data.Get("root_volume")) + helpers.Ensure("--namespace", data.Labels().Get("root_namespace"), "volume", "inspect", data.Labels().Get("root_volume")) }, ), } @@ -87,17 +87,17 @@ func TestVolumeNamespace(t *testing.T) { Description: "create with the same name should work, then delete it", NoParallel: true, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("volume", "create", data.Get("root_volume")) + return helpers.Command("volume", "create", data.Labels().Get("root_volume")) }, Cleanup: func(data test.Data, helpers test.Helpers) { - helpers.Anyhow("volume", "rm", data.Get("root_volume")) + helpers.Anyhow("volume", "rm", data.Labels().Get("root_volume")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: func(stdout string, info string, t *testing.T) { - helpers.Ensure("volume", "inspect", data.Get("root_volume")) - helpers.Ensure("volume", "rm", data.Get("root_volume")) - helpers.Ensure("--namespace", data.Get("root_namespace"), "volume", "inspect", data.Get("root_volume")) + helpers.Ensure("volume", "inspect", data.Labels().Get("root_volume")) + helpers.Ensure("volume", "rm", data.Labels().Get("root_volume")) + helpers.Ensure("--namespace", data.Labels().Get("root_namespace"), "volume", "inspect", data.Labels().Get("root_volume")) }, } }, diff --git a/cmd/nerdctl/volume/volume_prune_linux_test.go b/cmd/nerdctl/volume/volume_prune_linux_test.go index 10b4e6b85f6..16f69bca559 100644 --- a/cmd/nerdctl/volume/volume_prune_linux_test.go +++ b/cmd/nerdctl/volume/volume_prune_linux_test.go @@ -41,18 +41,18 @@ func TestVolumePrune(t *testing.T) { "-v", namedBusy+":/namedbusyvolume", "-v", anonIDBusy+":/anonbusyvolume", testutil.CommonImage) - data.Set("anonIDBusy", anonIDBusy) - data.Set("anonIDDangling", anonIDDangling) - data.Set("namedBusy", namedBusy) - data.Set("namedDangling", namedDangling) + data.Labels().Set("anonIDBusy", anonIDBusy) + data.Labels().Set("anonIDDangling", anonIDDangling) + data.Labels().Set("namedBusy", namedBusy) + data.Labels().Set("namedDangling", namedDangling) } var cleanup = func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) - helpers.Anyhow("volume", "rm", "-f", data.Get("anonIDBusy")) - helpers.Anyhow("volume", "rm", "-f", data.Get("anonIDDangling")) - helpers.Anyhow("volume", "rm", "-f", data.Get("namedBusy")) - helpers.Anyhow("volume", "rm", "-f", data.Get("namedDangling")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("anonIDBusy")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("anonIDDangling")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("namedBusy")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("namedDangling")) } testCase := nerdtest.Setup() @@ -69,15 +69,15 @@ func TestVolumePrune(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.DoesNotContain(data.Get("anonIDBusy")), - expect.Contains(data.Get("anonIDDangling")), - expect.DoesNotContain(data.Get("namedBusy")), - expect.DoesNotContain(data.Get("namedDangling")), + expect.DoesNotContain(data.Labels().Get("anonIDBusy")), + expect.Contains(data.Labels().Get("anonIDDangling")), + expect.DoesNotContain(data.Labels().Get("namedBusy")), + expect.DoesNotContain(data.Labels().Get("namedDangling")), func(stdout string, info string, t *testing.T) { - helpers.Ensure("volume", "inspect", data.Get("anonIDBusy")) - helpers.Fail("volume", "inspect", data.Get("anonIDDangling")) - helpers.Ensure("volume", "inspect", data.Get("namedBusy")) - helpers.Ensure("volume", "inspect", data.Get("namedDangling")) + helpers.Ensure("volume", "inspect", data.Labels().Get("anonIDBusy")) + helpers.Fail("volume", "inspect", data.Labels().Get("anonIDDangling")) + helpers.Ensure("volume", "inspect", data.Labels().Get("namedBusy")) + helpers.Ensure("volume", "inspect", data.Labels().Get("namedDangling")) }, ), } @@ -92,15 +92,15 @@ func TestVolumePrune(t *testing.T) { Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ Output: expect.All( - expect.DoesNotContain(data.Get("anonIDBusy")), - expect.Contains(data.Get("anonIDDangling")), - expect.DoesNotContain(data.Get("namedBusy")), - expect.Contains(data.Get("namedDangling")), + expect.DoesNotContain(data.Labels().Get("anonIDBusy")), + expect.Contains(data.Labels().Get("anonIDDangling")), + expect.DoesNotContain(data.Labels().Get("namedBusy")), + expect.Contains(data.Labels().Get("namedDangling")), func(stdout string, info string, t *testing.T) { - helpers.Ensure("volume", "inspect", data.Get("anonIDBusy")) - helpers.Fail("volume", "inspect", data.Get("anonIDDangling")) - helpers.Ensure("volume", "inspect", data.Get("namedBusy")) - helpers.Fail("volume", "inspect", data.Get("namedDangling")) + helpers.Ensure("volume", "inspect", data.Labels().Get("anonIDBusy")) + helpers.Fail("volume", "inspect", data.Labels().Get("anonIDDangling")) + helpers.Ensure("volume", "inspect", data.Labels().Get("namedBusy")) + helpers.Fail("volume", "inspect", data.Labels().Get("namedDangling")) }, ), } diff --git a/cmd/nerdctl/volume/volume_remove_linux_test.go b/cmd/nerdctl/volume/volume_remove_linux_test.go index 01680bd30ec..1fb98e77846 100644 --- a/cmd/nerdctl/volume/volume_remove_linux_test.go +++ b/cmd/nerdctl/volume/volume_remove_linux_test.go @@ -89,17 +89,17 @@ func TestVolumeRemove(t *testing.T) { } } assert.Assert(t, anonName != "", "Failed to find anonymous volume id", inspect) - data.Set("anonName", anonName) + data.Labels().Set("anonName", anonName) }, Cleanup: func(data test.Data, helpers test.Helpers) { helpers.Anyhow("rm", "-f", data.Identifier()) - helpers.Anyhow("volume", "rm", "-f", data.Get("anonName")) + helpers.Anyhow("volume", "rm", "-f", data.Labels().Get("anonName")) }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { // Try to remove that anon volume - return helpers.Command("volume", "rm", data.Get("anonName")) + return helpers.Command("volume", "rm", data.Labels().Get("anonName")) }, Expected: test.Expects(1, []error{errdefs.ErrFailedPrecondition}, nil), diff --git a/docs/testing/tools.md b/docs/testing/tools.md index 70230ae663b..9b4f0d9d1ad 100644 --- a/docs/testing/tools.md +++ b/docs/testing/tools.md @@ -109,7 +109,7 @@ that this name is then visible in the list of containers. To achieve that, you should write your own `Manager`, leveraging test `Data`. -Here is an example, where we are using `data.Get("sometestdata")`. +Here is an example, where we are using `data.Labels().Get("sometestdata")`. ```go package main @@ -133,7 +133,7 @@ func TestMyThing(t *testing.T) { // Declare your test myTest := &test.Case{ - Data: test.WithData("sometestdata", "blah"), + Data: test.WithLabels(map[string]string{"sometestdata": "blah"}), Command: test.Command("info"), Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -143,7 +143,7 @@ func TestMyThing(t *testing.T) { errdefs.ErrNotFound, }, Output: func(stdout string, info string, t *testing.T) { - assert.Assert(t, stdout == data.Get("sometestdata"), info) + assert.Assert(t, stdout == data.Labels().Get("sometestdata"), info) }, } }, @@ -157,7 +157,7 @@ func TestMyThing(t *testing.T) { `Data` is provided to allow storing mutable key-value information that pertain to the test. -While it can be provided through `test.WithData(key string, value string)`, +While it can be provided through `test.WithLabels(map[string]string{key: value})`, inside the testcase definition, it can also be dynamically manipulated inside `Setup`, or `Command`. Note that `Data` additionally exposes the following functions: @@ -244,9 +244,9 @@ func TestMyThing(t *testing.T) { // Declare your test myTest := &test.Case{ - Data: test.WithData("sometestdata", "blah"), + Data: test.WithLabels(map[string]string{"sometestdata": "blah"}), Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--name", data.Get("sometestdata")) + return helpers.Command("run", "--name", data.Labels().Get("sometestdata")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -256,7 +256,7 @@ func TestMyThing(t *testing.T) { errdefs.ErrNotFound, }, Output: func(stdout string, info string, t *testing.T) { - assert.Assert(t, stdout == data.Get("sometestdata"), info) + assert.Assert(t, stdout == data.Labels().Get("sometestdata"), info) }, } }, @@ -325,7 +325,7 @@ func TestMyThing(t *testing.T) { // Declare your test myTest := &test.Case{ - Data: test.WithData("sometestdata", "blah"), + Data: test.WithLabels(map[string]string{"sometestdata": "blah"}), Setup: func(data *test.Data, helpers test.Helpers){ helpers.Ensure("volume", "create", "foo") helpers.Ensure("volume", "create", "bar") @@ -335,7 +335,7 @@ func TestMyThing(t *testing.T) { helpers.Anyhow("volume", "rm", "bar") }, Command: func(data test.Data, helpers test.Helpers) test.TestableCommand { - return helpers.Command("run", "--name", data.Identifier()+data.Get("sometestdata")) + return helpers.Command("run", "--name", data.Identifier()+data.Labels().Get("sometestdata")) }, Expected: func(data test.Data, helpers test.Helpers) *test.Expected { return &test.Expected{ @@ -345,7 +345,7 @@ func TestMyThing(t *testing.T) { errdefs.ErrNotFound, }, Output: func(stdout string, info string, t *testing.T) { - assert.Assert(t, stdout == data.Get("sometestdata"), info) + assert.Assert(t, stdout == data.Labels().Get("sometestdata"), info) }, } }, diff --git a/mod/tigron/.golangci.yml b/mod/tigron/.golangci.yml index ab1817e4d1a..2e9b9894ae6 100644 --- a/mod/tigron/.golangci.yml +++ b/mod/tigron/.golangci.yml @@ -61,12 +61,15 @@ linters: revive: enable-all-rules: true rules: + - name: max-public-structs + # Default is 5 + arguments: 7 - name: cognitive-complexity # Default is 7 - arguments: [60] + arguments: [100] - name: function-length # Default is 50, 75 - arguments: [80, 200] + arguments: [80, 220] - name: cyclomatic # Default is 10 arguments: [30] diff --git a/mod/tigron/expect/doc.md b/mod/tigron/expect/doc.md index 48b8d4be6e9..7b2e9828df6 100644 --- a/mod/tigron/expect/doc.md +++ b/mod/tigron/expect/doc.md @@ -169,7 +169,7 @@ To achieve that, you should write your own `test.Manager` instead of using the h A manager is a simple function which only role is to return a `test.Expected` struct. The `test.Manager` signature makes available `test.Data` and `test.Helpers` to you. -Here is an example, where we are using `data.Get("sometestdata")`. +Here is an example, where we are using `data.Labels().Get("sometestdata")`. ```go package main @@ -191,7 +191,7 @@ func TestMyThing(t *testing.T) { // Do things... // ... // Save this for later - data.Set("something", "lalala") + data.Labels().Set("something", "lalala") } // Attach a command to run @@ -210,7 +210,7 @@ func TestMyThing(t *testing.T) { t.Helper() // Retrieve the data that was set during the Setup phase. - assert.Assert(t, stdout == data.Get("sometestdata"), info) + assert.Assert(t, stdout == data.Labels().Get("sometestdata"), info) }, } } diff --git a/mod/tigron/internal/com/command.go b/mod/tigron/internal/com/command.go index cc8959a7e13..c8cd6c3d21b 100644 --- a/mod/tigron/internal/com/command.go +++ b/mod/tigron/internal/com/command.go @@ -70,6 +70,7 @@ type Result struct { Stderr string ExitCode int Signal os.Signal + Duration time.Duration } type execution struct { @@ -102,9 +103,10 @@ type Command struct { ptyStderr bool ptyStdin bool - exec *execution - mutex sync.Mutex - result *Result + exec *execution + mutex sync.Mutex + result *Result + startTime time.Time } // Clone does just duplicate a command, resetting its execution. @@ -184,12 +186,12 @@ func (gc *Command) Run(parentCtx context.Context) error { ) // Get a timing-out context - timeout := gc.Timeout - if timeout == 0 { - timeout = defaultTimeout + if gc.Timeout == 0 { + gc.Timeout = defaultTimeout } - ctx, ctxCancel = context.WithTimeout(parentCtx, timeout) + ctx, ctxCancel = context.WithTimeout(parentCtx, gc.Timeout) + gc.startTime = time.Now() // Create a contextual command, set the logger cmd = gc.buildCommand(ctx) @@ -366,6 +368,7 @@ func (gc *Command) wrap() error { Stderr: pipes.fromStderr, Environ: cmd.Environ(), Signal: signal, + Duration: time.Since(gc.startTime), } if gc.exec.err == nil { diff --git a/mod/tigron/internal/formatter/formatter.go b/mod/tigron/internal/formatter/formatter.go index 43ce9fe56c4..f0900acbc3f 100644 --- a/mod/tigron/internal/formatter/formatter.go +++ b/mod/tigron/internal/formatter/formatter.go @@ -108,7 +108,10 @@ func chunk(s string, maxLength, maxLines int) []string { } if len(chunks) > maxLines { - chunks = append(chunks[0:maxLines], "...") + abbreviator := "..." + chunks = append( + append(chunks[0:maxLines/2], abbreviator+strings.Repeat(spacer, maxLength-len(abbreviator))), + chunks[len(chunks)-maxLines/2:]...) } else if len(chunks) == 0 { chunks = []string{strings.Repeat(spacer, maxLength)} } diff --git a/mod/tigron/test/case.go b/mod/tigron/test/case.go index 6a703e964a0..67846dfbb0f 100644 --- a/mod/tigron/test/case.go +++ b/mod/tigron/test/case.go @@ -19,7 +19,9 @@ package test import ( "encoding/json" "fmt" + "os" "slices" + "strings" "testing" "github.com/containerd/nerdctl/mod/tigron/internal/assertive" @@ -71,6 +73,7 @@ const ( setupDecorator = "🏗" subinDecorator = "⤵️" suboutDecorator = "↩️" + tempDecorator = "⏳" ) // Run prepares and executes the test, and any possible subtests. @@ -115,7 +118,7 @@ func (test *Case) Run(t *testing.T) { } // Inherit and attach Data and Config - test.Data = configureData(test.t, test.Data, parentData) + test.Data = newData(test.t, test.Data, parentData) test.Config = configureConfig(test.Config, parentConfig) var custCom CustomizableCommand @@ -125,9 +128,13 @@ func (test *Case) Run(t *testing.T) { custCom = registeredTestable.CustomCommand(test, test.t) } - custCom.WithCwd(test.Data.TempDir()) + // Separate cwd from the temp directory + custCom.WithCwd(test.t.TempDir()) custCom.withT(test.t) - custCom.withTempDir(test.Data.TempDir()) + // Set the command tempdir to another temp location. + // This is required for the current extension mechanism to allow creation of command dependent configuration + // assets. Note that this is a different location than both CWD and Data.Temp().Path(). + custCom.withTempDir(test.t.TempDir()) custCom.withEnv(test.Env) custCom.withConfig(test.Config) @@ -229,18 +236,28 @@ func (test *Case) Run(t *testing.T) { debugConfig, _ := json.MarshalIndent(test.Config.(*config).config, "", " ") debugData, _ := json.MarshalIndent(test.Data.(*data).labels, "", " ") + // Show the files in the temp directory BEFORE the command is executed + tempFiles := []string{} + + if files, err := os.ReadDir(test.Data.Temp().Path()); err == nil { + for _, file := range files { + tempFiles = append(tempFiles, file.Name()) + } + } + test.t.Log( "\n\n" + formatter.Table( [][]any{ {startDecorator, fmt.Sprintf("%q: starting test!", test.t.Name())}, - {"cwd", test.Data.TempDir()}, + {tempDecorator, test.Data.Temp().Dir()}, + {"", strings.Join(tempFiles, "\n")}, {"config", string(debugConfig)}, - {"data", string(debugData)}, + {"labels", string(debugData)}, }, "=", ) + "\n", ) - + // FIXME: so, the expected function will run BEFORE the command cmd.Run(test.Expected(test.Data, test.helpers)) } diff --git a/mod/tigron/test/command.go b/mod/tigron/test/command.go index 0c1970d8d81..899f0474574 100644 --- a/mod/tigron/test/command.go +++ b/mod/tigron/test/command.go @@ -39,6 +39,10 @@ const ( exitDecorator = "⚠️" stdoutDecorator = "🟢" stderrDecorator = "🟠" + timeoutDecorator = "⏰" + cwdDecorator = "📁" + envDecorator = "🌱" + sigDecorator = "⚡" ) // CustomizableCommand is an interface meant for people who want to heavily customize the base @@ -61,6 +65,7 @@ type CustomizableCommand interface { // Note that this will override any variable defined in the embedding environment withEnv(env map[string]string) // withTempDir specifies a temporary directory to use + // FIXME: this is only required because of the current command extension mechanism withTempDir(path string) // WithConfig allows passing custom config properties from the test to the base command withConfig(config Config) @@ -138,6 +143,10 @@ func (gc *GenericCommand) WithBlacklist(env []string) { gc.cmd.EnvBlackList = env } +func (gc *GenericCommand) WithWhitelist(env []string) { + gc.cmd.EnvWhiteList = env +} + func (gc *GenericCommand) WithTimeout(timeout time.Duration) { gc.cmd.Timeout = timeout } @@ -193,12 +202,18 @@ func (gc *GenericCommand) Run(expect *Expected) { } if result.Signal != nil { - debug = append(debug, []any{"Signal", result.Signal.String()}) + debug = append(debug, []any{"", sigDecorator + " " + result.Signal.String()}) + } + + duration := result.Duration.String() + if result.Duration < time.Second { + duration = "<1s" } debug = append(debug, - []any{"Limit", gc.cmd.Timeout}, - []any{"Environ", strings.Join(result.Environ, "\n")}, + []any{envDecorator, strings.Join(result.Environ, "\n")}, + []any{timeoutDecorator, duration + " (limit: " + gc.cmd.Timeout.String() + ")"}, + []any{cwdDecorator, gc.cmd.WorkingDir}, ) } diff --git a/mod/tigron/test/consts.go b/mod/tigron/test/consts.go new file mode 100644 index 00000000000..a54b54a9e55 --- /dev/null +++ b/mod/tigron/test/consts.go @@ -0,0 +1,26 @@ +/* + Copyright The containerd Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ + +package test + +const ( + // FilePermissionsDefault specifies the default creation mode for temporary files. + // Note that umask will affect these. + FilePermissionsDefault = 0o644 + // DirPermissionsDefault specifies the default creation mode for temporary directories. + // Note that umask will affect these. + DirPermissionsDefault = 0o755 +) diff --git a/mod/tigron/test/data.go b/mod/tigron/test/data.go index 8907b9ca199..d5583d60b2d 100644 --- a/mod/tigron/test/data.go +++ b/mod/tigron/test/data.go @@ -19,9 +19,13 @@ package test import ( "crypto/sha256" "fmt" + "os" + "path/filepath" "regexp" "strings" - "testing" + + "github.com/containerd/nerdctl/mod/tigron/internal/assertive" + "github.com/containerd/nerdctl/mod/tigron/tig" ) const ( @@ -30,79 +34,181 @@ const ( identifierSignatureLength = 8 ) -// WithData returns a data object with a certain key value set. -func WithData(key, value string) Data { - dat := &data{} - dat.Set(key, value) +// WithLabels returns a Data object with specific key value labels set. +func WithLabels(in map[string]string) Data { + dat := &data{ + labels: &labels{ + inMap: in, + }, + temp: &temp{}, + } return dat } -// Contains the implementation of the Data interface. -func configureData(t *testing.T, seedData, parent Data) Data { - t.Helper() +type labels struct { + inMap map[string]string +} - if seedData == nil { - seedData = &data{} - } +func (lb *labels) Get(key string) string { + return lb.inMap[key] +} - //nolint:forcetypeassert - dat := &data{ - // Note: implementation dependent - labels: seedData.(*data).labels, - tempDir: t.TempDir(), - testID: func(suffix ...string) string { - suffix = append([]string{t.Name()}, suffix...) +func (lb *labels) Set(key, value string) { + lb.inMap[key] = value +} - return defaultIdentifierHashing(suffix...) - }, - } +type temp struct { + tempDir string + t tig.T +} - if parent != nil { - dat.adopt(parent) - } +func (tp *temp) Load(key ...string) string { + tp.t.Helper() - return dat + pth := filepath.Join(append([]string{tp.tempDir}, key...)...) + + //nolint:gosec // Fine in the context of testing + content, err := os.ReadFile(pth) + + assertive.ErrorIsNil( + assertive.WithSilentSuccess(tp.t), + err, + fmt.Sprintf("Loading file %q must succeed", pth), + ) + + return string(content) } -type data struct { - labels map[string]string - testID func(suffix ...string) string - tempDir string +func (tp *temp) Exists(key ...string) { + tp.t.Helper() + + pth := filepath.Join(append([]string{tp.tempDir}, key...)...) + + _, err := os.Stat(pth) + + assertive.ErrorIsNil( + assertive.WithSilentSuccess(tp.t), + err, + fmt.Sprintf("File %q must exist", pth), + ) } -func (dt *data) Get(key string) string { - return dt.labels[key] +func (tp *temp) Save(value string, key ...string) string { + tp.t.Helper() + + tp.Dir(key[:len(key)-1]...) + + pth := filepath.Join(append([]string{tp.tempDir}, key...)...) + + err := os.WriteFile( + pth, + []byte(value), + FilePermissionsDefault, + ) + + assertive.ErrorIsNil( + assertive.WithSilentSuccess(tp.t), + err, + fmt.Sprintf("Saving file %q must succeed", filepath.Join(key...)), + ) + + return pth } -func (dt *data) Set(key, value string) Data { - if dt.labels == nil { - dt.labels = map[string]string{} - } +func (tp *temp) Dir(key ...string) string { + tp.t.Helper() + + pth := filepath.Join(append([]string{tp.tempDir}, key...)...) + err := os.MkdirAll(pth, DirPermissionsDefault) + + assertive.ErrorIsNil( + assertive.WithSilentSuccess(tp.t), + err, + fmt.Sprintf("Creating directory %q must succeed", pth), + ) + + return pth +} + +func (tp *temp) Path(key ...string) string { + tp.t.Helper() - dt.labels[key] = value + return filepath.Join(append([]string{tp.tempDir}, key...)...) +} - return dt +type data struct { + temp DataTemp + labels DataLabels + testID func(suffix ...string) string } func (dt *data) Identifier(suffix ...string) string { return dt.testID(suffix...) } -func (dt *data) TempDir() string { - return dt.tempDir +func (dt *data) Labels() DataLabels { + return dt.labels } -func (dt *data) adopt(parent Data) { - // Note: implementation dependent - if castData, ok := parent.(*data); ok { - for k, v := range castData.labels { +func (dt *data) Temp() DataTemp { + return dt.temp +} + +// Contains the implementation of the Data interface +// +//nolint:varnamelen +func newData(t tig.T, seed, parent Data) Data { + t.Helper() + + t = assertive.WithSilentSuccess(t) + + seedMap := map[string]string{} + + if seed != nil { + if inLab, ok := seed.Labels().(*labels); ok { + seedMap = inLab.inMap + } + } + + if parent != nil { + for k, v := range parent.Labels().(*labels).inMap { // Only copy keys that are not set already - if _, ok := dt.labels[k]; !ok { - dt.Set(k, v) + if _, ok := seedMap[k]; !ok { + seedMap[k] = v } } } + + // NOTE: certain systems will use the path dirname to decide how they name resources. + // t.TempDir() will always return /tmp/TestTempDir2153252249/001, meaning these systems will all + // use the identical 001 part. This is true for compose specifically. + // Appending the base test identifier here would guarantee better unicity. + // Note though that Windows will barf if >256 characters, so, hashing... + // Small caveat: identically named tests in different modules WILL still end-up with the same last segment. + tempDir := filepath.Join( + t.TempDir(), + fmt.Sprintf("%x", sha256.Sum256([]byte(t.Name())))[0:identifierSignatureLength], + ) + + assertive.ErrorIsNil(t, os.MkdirAll(tempDir, DirPermissionsDefault)) + + dat := &data{ + labels: &labels{ + inMap: seedMap, + }, + temp: &temp{ + tempDir: tempDir, + t: t, + }, + testID: func(suffix ...string) string { + suffix = append([]string{t.Name()}, suffix...) + + return defaultIdentifierHashing(suffix...) + }, + } + + return dat } func defaultIdentifierHashing(names ...string) string { diff --git a/mod/tigron/test/data_test.go b/mod/tigron/test/data_test.go index dff839d6026..37e0c1c010b 100644 --- a/mod/tigron/test/data_test.go +++ b/mod/tigron/test/data_test.go @@ -24,34 +24,45 @@ import ( "github.com/containerd/nerdctl/mod/tigron/internal/assertive" ) -func TestDataBasic(t *testing.T) { +func TestLabels(t *testing.T) { t.Parallel() - dataObj := WithData("test", "create") + dataLabels := WithLabels(map[string]string{"test": "create"}).Labels() - assertive.IsEqual(t, dataObj.Get("test"), "create") - assertive.IsEqual(t, dataObj.Get("doesnotexist"), "") + assertive.IsEqual(t, dataLabels.Get("test"), "create") + assertive.IsEqual(t, dataLabels.Get("doesnotexist"), "") - dataObj.Set("test", "set") - assertive.IsEqual(t, dataObj.Get("test"), "set") + dataLabels.Set("test", "set") + assertive.IsEqual(t, dataLabels.Get("test"), "set") + + dataLabels.Set("test", "reset") + assertive.IsEqual(t, dataLabels.Get("test"), "reset") } -func TestDataTempDir(t *testing.T) { +func TestTemp(t *testing.T) { t.Parallel() - dataObj := configureData(t, nil, nil) + dataObj := newData(t, nil, nil) - one := dataObj.TempDir() - two := dataObj.TempDir() + one := dataObj.Temp().Path() + two := dataObj.Temp().Path() assertive.IsEqual(t, one, two) assertive.IsNotEqual(t, one, "") + + t.Run("verify that subtest has an independent TempDir", func(t *testing.T) { + t.Parallel() + + dataObj = newData(t, nil, nil) + three := dataObj.Temp().Path() + assertive.IsNotEqual(t, one, three) + }) } func TestDataIdentifier(t *testing.T) { t.Parallel() - dataObj := configureData(t, nil, nil) + dataObj := newData(t, nil, nil) one := dataObj.Identifier() two := dataObj.Identifier() @@ -68,7 +79,7 @@ func TestDataIdentifierThatIsReallyReallyReallyReallyReallyReallyReallyReallyRea ) { t.Parallel() - dataObj := configureData(t, nil, nil) + dataObj := newData(t, nil, nil) one := dataObj.Identifier() two := dataObj.Identifier() diff --git a/mod/tigron/test/funct.go b/mod/tigron/test/funct.go index 8614b9cbefb..45b4abbd9d9 100644 --- a/mod/tigron/test/funct.go +++ b/mod/tigron/test/funct.go @@ -25,8 +25,11 @@ type Evaluator func(data Data, helpers Helpers) (bool, string) // or Requirement. type Butler func(data Data, helpers Helpers) +// TODO: when we will break API: +// - remove the info parameter +// - move to tig.T + // A Comparator is the function signature to implement for the Output property of an Expected. -// TODO: when we will break API, remove the info parameter. type Comparator func(stdout, info string, t *testing.T) // A Manager is the function signature meant to produce expectations for a command. diff --git a/mod/tigron/test/interfaces.go b/mod/tigron/test/interfaces.go index 07f348999c5..09b0abf84fa 100644 --- a/mod/tigron/test/interfaces.go +++ b/mod/tigron/test/interfaces.go @@ -23,22 +23,44 @@ import ( "time" ) -// Data is meant to hold information about a test: -// - first, any random key value data that the test implementer wants to carry / modify - this is -// test data - second, some commonly useful immutable test properties (a way to generate unique -// identifiers for that test, temporary directory, etc.) -// Note that Data is inherited, from parent test to subtest (except for Identifier and TempDir of -// course). -type Data interface { - // Get returns the value of a certain key for custom data +// DataLabels holds key-value test information set by the test authors. +// Note that retrieving a non-existent label will return the empty string. +type DataLabels interface { + // Get returns the value of the requested label. Get(key string) string - // Set will save `value` for `key` - Set(key, value string) Data + // Set will save the label `key` with `value`. + Set(key, value string) +} - // Identifier returns the test identifier that can be used to name resources +// DataTemp allows test authors to easily manipulate test fixtures / temporary files. +type DataTemp interface { + // Load will retrieve the content stored in the file + // Asserts on failure. + Load(key ...string) string + // Save will store the content in the file, ensuring parent dir exists, and return the path. + // Asserts on failure. + Save(data string, key ...string) string + // Path will return the absolute path for the asset, whether it exists or not. + Path(key ...string) string + // Exists asserts that the object exist. + Exists(key ...string) + // Dir ensures the directory under temp is created, and returns the path. + // Asserts on failure. + Dir(key ...string) string +} + +// Data is meant to hold information about a test: +// - first, key-value data that the test implementer wants to carry around - this is Labels() +// - second, some commonly useful immutable test properties (eg: a way to generate unique +// identifiers for that test) +// - third, ability to manipulate test files inside managed temporary directories +// Note that Data Labels are inherited from parent test to subtest. +// This is not true for Identifier and Temp().Dir(), which are bound to the test itself, though temporary files +// can be accessed by subtests if their location is passed around (in Labels). +type Data interface { + Temp() DataTemp + Labels() DataLabels Identifier(suffix ...string) string - // TempDir returns the test temporary directory - TempDir() string } // Helpers provides a set of helpers to run commands with simple expectations, diff --git a/pkg/testutil/nerdtest/ca/ca.go b/pkg/testutil/nerdtest/ca/ca.go index 08615f7058b..49d69f81b4f 100644 --- a/pkg/testutil/nerdtest/ca/ca.go +++ b/pkg/testutil/nerdtest/ca/ca.go @@ -69,8 +69,7 @@ func New(data test.Data, t *testing.T) *CA { BasicConstraintsValid: true, } - dir, err := os.MkdirTemp(data.TempDir(), "ca") - assert.NilError(t, err) + dir := data.Temp().Dir("ca") keyPath := filepath.Join(dir, "ca.key") certPath := filepath.Join(dir, "ca.cert") writePair(t, keyPath, certPath, cert, cert, key, key) diff --git a/pkg/testutil/nerdtest/command.go b/pkg/testutil/nerdtest/command.go index dbeed949e7c..d3ca847119a 100644 --- a/pkg/testutil/nerdtest/command.go +++ b/pkg/testutil/nerdtest/command.go @@ -82,17 +82,14 @@ func newNerdCommand(conf test.Config, t *testing.T) *nerdCommand { } ret.WithBinary(binary) - // Not interested in these - and insulate us from parent environment side effects - ret.WithBlacklist([]string{ - "LS_COLORS", - "DOCKER_CONFIG", - "CONTAINERD_SNAPSHOTTER", - "NERDCTL_TOML", - "CONTAINERD_ADDRESS", - "CNI_PATH", - "NETCONFPATH", - "NERDCTL_EXPERIMENTAL", - "NERDCTL_HOST_GATEWAY_IP", + ret.WithWhitelist([]string{ + "PATH", + "HOME", + "XDG_*", + // Windows needs ProgramData, AppData, etc + "Program*", + "PROGRAM*", + "APPDATA", }) return ret } @@ -133,7 +130,7 @@ func (nc *nerdCommand) prep() { if customDCConfig := nc.GenericCommand.Config.Read(DockerConfig); customDCConfig != "" { if !nc.hasWrittenDockerConfig { dest := filepath.Join(nc.Env["DOCKER_CONFIG"], "config.json") - err := os.WriteFile(dest, []byte(customDCConfig), 0400) + err := os.WriteFile(dest, []byte(customDCConfig), test.FilePermissionsDefault) assert.NilError(nc.T(), err, "failed to write custom docker config json file for test") nc.hasWrittenDockerConfig = true } @@ -177,7 +174,7 @@ func (nc *nerdCommand) prep() { if nc.Config.Read(NerdctlToml) != "" { if !nc.hasWrittenToml { dest := nc.Env["NERDCTL_TOML"] - err := os.WriteFile(dest, []byte(nc.Config.Read(NerdctlToml)), 0400) + err := os.WriteFile(dest, []byte(nc.Config.Read(NerdctlToml)), test.FilePermissionsDefault) assert.NilError(nc.T(), err, "failed to write NerdctlToml") nc.hasWrittenToml = true } diff --git a/pkg/testutil/nerdtest/registry/cesanta.go b/pkg/testutil/nerdtest/registry/cesanta.go index 58bc361f212..111286e3c6b 100644 --- a/pkg/testutil/nerdtest/registry/cesanta.go +++ b/pkg/testutil/nerdtest/registry/cesanta.go @@ -128,10 +128,6 @@ func NewCesantaAuthServer(data test.Data, helpers test.Helpers, ca *ca.CA, port assert.NilError(helpers.T(), err, fmt.Errorf("failed bcrypt encrypting password: %w", err)) // Prepare configuration file for authentication server // Details: https://github.com/cesanta/docker_auth/blob/1.7.1/examples/simple.yml - configFile, err := os.CreateTemp(data.TempDir(), "authconfig") - assert.NilError(helpers.T(), err, fmt.Errorf("failed creating temporary directory for config file: %w", err)) - configFileName := configFile.Name() - cc := &CesantaConfig{ Server: CesantaConfigServer{ Addr: ":5100", @@ -165,6 +161,7 @@ func NewCesantaAuthServer(data test.Data, helpers test.Helpers, ca *ca.CA, port cc.Token.Key = "/auth/domain.key" } + configFileName := data.Temp().Path("authconfig") err = cc.Save(configFileName) assert.NilError(helpers.T(), err, fmt.Errorf("failed writing configuration: %w", err)) @@ -181,20 +178,12 @@ func NewCesantaAuthServer(data test.Data, helpers test.Helpers, ca *ca.CA, port helpers.Ensure("rm", "-f", containerName) errPortRelease := portlock.Release(port) errCertClose := cert.Close() - errConfigClose := configFile.Close() - errConfigRemove := os.Remove(configFileName) if errPortRelease != nil { helpers.T().Error(errPortRelease.Error()) } if errCertClose != nil { helpers.T().Error(errCertClose.Error()) } - if errConfigClose != nil { - helpers.T().Error(errConfigClose.Error()) - } - if errConfigRemove != nil { - helpers.T().Error(errConfigRemove.Error()) - } } setup := func(data test.Data, helpers test.Helpers) { diff --git a/pkg/testutil/nerdtest/registry/common.go b/pkg/testutil/nerdtest/registry/common.go index d662d00f7c0..53877c0809d 100644 --- a/pkg/testutil/nerdtest/registry/common.go +++ b/pkg/testutil/nerdtest/registry/common.go @@ -19,8 +19,6 @@ package registry import ( "fmt" "net" - "os" - "path/filepath" "golang.org/x/crypto/bcrypt" @@ -71,9 +69,7 @@ func (ba *BasicAuth) Params(data test.Data) []string { if ba.HtFile == "" && ba.Username != "" && ba.Password != "" { pass := ba.Password encryptedPass, _ := bcrypt.GenerateFromPassword([]byte(pass), bcrypt.DefaultCost) - tmpDir, _ := os.MkdirTemp(data.TempDir(), "htpasswd") - ba.HtFile = filepath.Join(tmpDir, "htpasswd") - _ = os.WriteFile(ba.HtFile, []byte(fmt.Sprintf(`%s:%s`, ba.Username, string(encryptedPass[:]))), 0600) + ba.HtFile = data.Temp().Save(fmt.Sprintf(`%s:%s`, ba.Username, string(encryptedPass[:])), "htpasswd") } ret := []string{ "--env", "REGISTRY_AUTH=htpasswd", diff --git a/pkg/testutil/nerdtest/registry/docker.go b/pkg/testutil/nerdtest/registry/docker.go index 30ee7626b53..82cde7f21d6 100644 --- a/pkg/testutil/nerdtest/registry/docker.go +++ b/pkg/testutil/nerdtest/registry/docker.go @@ -96,7 +96,7 @@ func NewDockerRegistry(data test.Data, helpers test.Helpers, currentCA *ca.CA, p // FIXME: in the future, we will want to further manipulate hosts toml file from the test // This should then return the struct, instead of saving it on its own hostsDir, err := func() (string, error) { - hDir, err := os.MkdirTemp(data.TempDir(), "certs.d") + hDir := data.Temp().Dir("certs.d") assert.NilError(helpers.T(), err, fmt.Errorf("failed creating directory certs.d: %w", err)) if currentCA != nil { diff --git a/pkg/testutil/nerdtest/requirements.go b/pkg/testutil/nerdtest/requirements.go index 3566b273f0d..90291a28aef 100644 --- a/pkg/testutil/nerdtest/requirements.go +++ b/pkg/testutil/nerdtest/requirements.go @@ -342,7 +342,7 @@ var Private = &test.Requirement{ // We need this to happen NOW and not in setup, as otherwise cleanup with operate on the default namespace namespace := data.Identifier("private") helpers.Write(Namespace, test.ConfigValue(namespace)) - data.Set("_deletenamespace", namespace) + data.Labels().Set("_deletenamespace", namespace) // FIXME: is this necessary? Should NoParallel be subsumed into config? helpers.Write(modePrivate, enabled) return true, "private mode creates a dedicated namespace for nerdctl, and disable parallelism for docker" @@ -356,7 +356,7 @@ var Private = &test.Requirement{ helpers.Ensure(append([]string{"rm", "-f"}, strings.Split(containerList, "\n")...)...) } helpers.Ensure("system", "prune", "-f", "--all", "--volumes") - helpers.Anyhow("namespace", "remove", data.Get("_deletenamespace")) + helpers.Anyhow("namespace", "remove", data.Labels().Get("_deletenamespace")) } }, } diff --git a/pkg/testutil/nerdtest/utilities.go b/pkg/testutil/nerdtest/utilities.go index 56cae946170..71b2d662f5c 100644 --- a/pkg/testutil/nerdtest/utilities.go +++ b/pkg/testutil/nerdtest/utilities.go @@ -25,6 +25,7 @@ import ( "github.com/containerd/nerdctl/mod/tigron/expect" "github.com/containerd/nerdctl/mod/tigron/test" + "github.com/containerd/nerdctl/mod/tigron/tig" "github.com/containerd/nerdctl/v2/pkg/inspecttypes/dockercompat" "github.com/containerd/nerdctl/v2/pkg/inspecttypes/native" @@ -46,58 +47,54 @@ func IsDocker() bool { // InspectContainer is a helper that can be used inside custom commands or Setup func InspectContainer(helpers test.Helpers, name string) dockercompat.Container { helpers.T().Helper() - var dc []dockercompat.Container + var res dockercompat.Container cmd := helpers.Command("container", "inspect", name) cmd.Run(&test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - err := json.Unmarshal([]byte(stdout), &dc) - assert.NilError(t, err, "Unable to unmarshal output\n"+info) - assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - }, + Output: expect.JSON([]dockercompat.Container{}, func(dc []dockercompat.Container, _ string, t tig.T) { + assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results") + res = dc[0] + }), }) - return dc[0] + return res } func InspectVolume(helpers test.Helpers, name string) native.Volume { helpers.T().Helper() - var dc []native.Volume + var res native.Volume cmd := helpers.Command("volume", "inspect", name) cmd.Run(&test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - err := json.Unmarshal([]byte(stdout), &dc) - assert.NilError(t, err, "Unable to unmarshal output\n"+info) - assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - }, + Output: expect.JSON([]native.Volume{}, func(dc []native.Volume, _ string, t tig.T) { + assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results") + res = dc[0] + }), }) - return dc[0] + return res } func InspectNetwork(helpers test.Helpers, name string) dockercompat.Network { helpers.T().Helper() - var dc []dockercompat.Network + var res dockercompat.Network cmd := helpers.Command("network", "inspect", name) cmd.Run(&test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - err := json.Unmarshal([]byte(stdout), &dc) - assert.NilError(t, err, "Unable to unmarshal output\n"+info) - assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - }, + Output: expect.JSON([]dockercompat.Network{}, func(dc []dockercompat.Network, _ string, t tig.T) { + assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results") + res = dc[0] + }), }) - return dc[0] + return res } func InspectImage(helpers test.Helpers, name string) dockercompat.Image { helpers.T().Helper() - var dc []dockercompat.Image + var res dockercompat.Image cmd := helpers.Command("image", "inspect", name) cmd.Run(&test.Expected{ - Output: func(stdout string, info string, t *testing.T) { - err := json.Unmarshal([]byte(stdout), &dc) - assert.NilError(t, err, "Unable to unmarshal output\n"+info) - assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results\n"+info) - }, + Output: expect.JSON([]dockercompat.Image{}, func(dc []dockercompat.Image, _ string, t tig.T) { + assert.Equal(t, 1, len(dc), "Unexpectedly got multiple results") + res = dc[0] + }), }) - return dc[0] + return res } const (