[WIP] rewriting image tests

Signed-off-by: apostasie <[email protected]>

cmd/nerdctl/image/image_convert_test.go

@@ -17,54 +17,123 @@
 package image
 
 import (
-	"runtime"
+	"fmt"
 	"testing"
 
 	"github.com/containerd/nerdctl/v2/pkg/testutil"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/test"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/testregistry"
 )
 
 func TestImageConvert(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("no windows support yet")
-	}
-	testutil.DockerIncompatible(t)
-	base := testutil.NewBase(t)
-	t.Parallel()
-
-	base.Cmd("pull", testutil.CommonImage).AssertOK()
+	nerdtest.Setup()
 
-	testCases := []struct {
-		identifier string
-		args       []string
-	}{
-		{
-			"esgz",
-			[]string{"--estargz"},
-		},
-		{
-			"zstd",
-			[]string{"--zstd", "--zstd-compression-level", "3"},
+	testCase := &test.Case{
+		Description: "Test image conversion",
+		Require: test.Require(
+			test.Not(test.Windows),
+			test.Not(nerdtest.Docker),
+		),
+		Setup: func(data test.Data, helpers test.Helpers) {
+			helpers.Ensure("pull", testutil.CommonImage)
 		},
-		{
-			"zstdchunked",
-			[]string{"--zstdchunked", "--zstdchunked-compression-level", "3"},
+		SubTests: []*test.Case{
+			{
+				Description: "esgz",
+				Cleanup: func(data test.Data, helpers test.Helpers) {
+					helpers.Anyhow("rmi", data.Identifier())
+				},
+				Command: func(data test.Data, helpers test.Helpers) test.Command {
+					return helpers.Command("image", "convert", "--oci", "--estargz", testutil.CommonImage, data.Identifier())
+				},
+				Expected: test.Expects(0, nil, nil),
+			},
+			{
+				Description: "nydus",
+				Require: test.Require(
+					test.Binary("nydus-image"),
+				),
+				Cleanup: func(data test.Data, helpers test.Helpers) {
+					helpers.Anyhow("rmi", data.Identifier())
+				},
+				Command: func(data test.Data, helpers test.Helpers) test.Command {
+					return helpers.Command("image", "convert", "--oci", "--nydus", testutil.CommonImage, data.Identifier())
+				},
+				Expected: test.Expects(0, nil, nil),
+			},
+			{
+				Description: "zstd",
+				Cleanup: func(data test.Data, helpers test.Helpers) {
+					helpers.Anyhow("rmi", data.Identifier())
+				},
+				Command: func(data test.Data, helpers test.Helpers) test.Command {
+					return helpers.Command("image", "convert", "--oci", "--zstd", "--zstd-compression-level", "3", testutil.CommonImage, data.Identifier())
+				},
+				Expected: test.Expects(0, nil, nil),
+			},
+			{
+				Description: "zstdchunked",
+				Cleanup: func(data test.Data, helpers test.Helpers) {
+					helpers.Anyhow("rmi", data.Identifier())
+				},
+				Command: func(data test.Data, helpers test.Helpers) test.Command {
+					return helpers.Command("image", "convert", "--oci", "--zstdchunked", "--zstdchunked-compression-level", "3", testutil.CommonImage, data.Identifier())
+				},
+				Expected: test.Expects(0, nil, nil),
+			},
 		},
 	}
 
-	for _, tc := range testCases {
-		convertedImage := testutil.Identifier(t) + ":" + tc.identifier
-		args := append([]string{"image", "convert", "--oci"}, tc.args...)
-		args = append(args, testutil.CommonImage, convertedImage)
+	testCase.Run(t)
+
+}
 
-		t.Run(tc.identifier, func(t *testing.T) {
-			t.Parallel()
+func TestImageConvertNydusVerify(t *testing.T) {
+	nerdtest.Setup()
 
-			base.Cmd("rmi", convertedImage).Run()
-			t.Cleanup(func() {
-				base.Cmd("rmi", convertedImage).Run()
-			})
+	var registry *testregistry.RegistryServer
 
-			base.Cmd(args...).AssertOK()
-		})
+	testCase := &test.Case{
+		Description: "TestImageConvertNydusVerify",
+		Require: test.Require(
+			test.Linux,
+			test.Binary("nydus-image"),
+			test.Binary("nydusify"),
+			test.Binary("nydusd"),
+			test.Not(nerdtest.Docker),
+			test.Not(nerdtest.Rootless),
+		),
+		Setup: func(data test.Data, helpers test.Helpers) {
+			helpers.Ensure("pull", testutil.CommonImage)
+			base := testutil.NewBase(t)
+			registry = testregistry.NewWithNoAuth(base, 80, false)
+			helpers.Ensure("image", "convert", "--nydus", "--oci",
+				testutil.CommonImage, data.Identifier())
+			data.Set("remoteImage", fmt.Sprintf("%s:%d/nydusd-image:test", "localhost", registry.Port))
+			helpers.Ensure("tag", data.Identifier(), data.Get("remoteImage"))
+			helpers.Ensure("push", data.Get("remoteImage"))
+		},
+		Cleanup: func(data test.Data, helpers test.Helpers) {
+			helpers.Anyhow("rmi", data.Get("remoteImage"))
+			helpers.Anyhow("rmi", data.Identifier())
+			if registry != nil {
+				registry.Cleanup(nil)
+			}
+		},
+		Command: func(data test.Data, helpers test.Helpers) test.Command {
+			return helpers.CustomCommand("nydusify",
+				"check",
+				"--source",
+				testutil.CommonImage,
+				"--target",
+				data.Get("remoteImage"),
+				"--source-insecure",
+				"--target-insecure",
+			)
+		},
+		Expected: test.Expects(0, nil, nil),
 	}
+
+	testCase.Run(t)
 }

cmd/nerdctl/image/image_encrypt_test.go

@@ -18,47 +18,18 @@ package image
 
 import (
 	"fmt"
-	"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
-	"github.com/containerd/nerdctl/v2/pkg/testutil/test"
-	"gotest.tools/v3/assert"
 	"strings"
 	"testing"
 
+	"gotest.tools/v3/assert"
+
 	testhelpers "github.com/containerd/nerdctl/v2/cmd/nerdctl/helpers"
 	"github.com/containerd/nerdctl/v2/pkg/testutil"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/test"
 	"github.com/containerd/nerdctl/v2/pkg/testutil/testregistry"
 )
 
-func TestImageEncryptJWEOLD(t *testing.T) {
-	testutil.RequiresBuild(t)
-	testutil.DockerIncompatible(t)
-	keyPair := testhelpers.NewJWEKeyPair(t)
-	base := testutil.NewBase(t)
-	tID := testutil.Identifier(t)
-	reg := testregistry.NewWithNoAuth(base, 0, false)
-
-	defer keyPair.Cleanup()
-	defer reg.Cleanup(nil)
-
-	base.Cmd("pull", testutil.CommonImage).AssertOK()
-	encryptImageRef := fmt.Sprintf("127.0.0.1:%d/%s:encrypted", reg.Port, tID)
-	base.Cmd("image", "encrypt", "--recipient=jwe:"+keyPair.Pub, testutil.CommonImage, encryptImageRef).AssertOK()
-	base.Cmd("image", "inspect", "--mode=native", "--format={{len .Index.Manifests}}", encryptImageRef).AssertOutExactly("1\n")
-	base.Cmd("image", "inspect", "--mode=native", "--format={{json .Manifest.Layers}}", encryptImageRef).AssertOutContains("org.opencontainers.image.enc.keys.jwe")
-	base.Cmd("push", encryptImageRef).AssertOK()
-
-	defer base.Cmd("rmi", encryptImageRef).Run()
-
-	// remove all local images (in the nerdctl-test namespace), to ensure that we do not have blobs of the original image.
-	testhelpers.RmiAll(base)
-	base.Cmd("pull", encryptImageRef).AssertFail() // defaults to --unpack=true, and fails due to missing prv key
-	base.Cmd("pull", "--unpack=false", encryptImageRef).AssertOK()
-	decryptImageRef := tID + ":decrypted"
-	defer base.Cmd("rmi", decryptImageRef).Run()
-	base.Cmd("image", "decrypt", "--key="+keyPair.Pub, encryptImageRef, decryptImageRef).AssertFail() // decryption needs prv key, not pub key
-	base.Cmd("image", "decrypt", "--key="+keyPair.Prv, encryptImageRef, decryptImageRef).AssertOK()
-}
-
 func TestImageEncryptJWE(t *testing.T) {
 	nerdtest.Setup()
 
@@ -69,16 +40,15 @@ func TestImageEncryptJWE(t *testing.T) {
 		Description: "TestImageEncryptJWE",
 		Require: test.Require(
 			test.Linux,
-			nerdtest.Build,
 			test.Not(nerdtest.Docker),
-			// This test wants to rmi all images
+			// This test needs to rmi the common image
 			nerdtest.Private,
 		),
 		Cleanup: func(data test.Data, helpers test.Helpers) {
 			if registry != nil {
 				registry.Cleanup(nil)
 				keyPair.Cleanup()
-				helpers.Anyhow("rmi", "-f", fmt.Sprintf("127.0.0.1:%d/%s:encrypted", registry.Port, data.Identifier()))
+				helpers.Anyhow("rmi", "-f", data.Get("encryptImageRef"))
 			}
 			helpers.Anyhow("rmi", "-f", data.Identifier())
 		},
@@ -94,8 +64,8 @@ func TestImageEncryptJWE(t *testing.T) {
 			inspector = helpers.Capture("image", "inspect", "--mode=native", "--format={{json .Manifest.Layers}}", encryptImageRef)
 			assert.Assert(t, strings.Contains(inspector, "org.opencontainers.image.enc.keys.jwe"))
 			helpers.Ensure("push", encryptImageRef)
-			helpers.Ensure("rmi", encryptImageRef)
-			testhelpers.RmiAll(base)
+			helpers.Anyhow("rmi", "-f", encryptImageRef)
+			helpers.Anyhow("rmi", "-f", testutil.CommonImage)
 			data.Set("encryptImageRef", encryptImageRef)
 		},
 		Command: func(data test.Data, helpers test.Helpers) test.Command {