manifest: Add unit tests for manifest inspect command

Add tests for tag/digest references and verbose modes

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

Author: ChengyuZhu6

cmd/nerdctl/manifest/manifest_inspect_linux_test.go

@@ -0,0 +1,140 @@
+/*
+   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 manifest
+
+import (
+	"encoding/json"
+	"testing"
+
+	"gotest.tools/v3/assert"
+
+	"github.com/containerd/nerdctl/mod/tigron/test"
+	"github.com/containerd/nerdctl/mod/tigron/tig"
+
+	"github.com/containerd/nerdctl/v2/pkg/testutil"
+	"github.com/containerd/nerdctl/v2/pkg/testutil/nerdtest"
+)
+
+var (
+	alpineDigest            = testutil.GetTestImageDigest("alpine")
+	alpineAmd64ConfigDigest = testutil.GetTestImageConfigDigest("alpine", "linux/amd64")
+	alpineAmd64Digest       = testutil.GetTestImageManifestDigest("alpine", "linux/amd64")
+)
+
+func TestManifestInspect(t *testing.T) {
+	testCase := nerdtest.Setup()
+	testCase.Setup = func(data test.Data, helpers test.Helpers) {
+		helpers.Ensure("pull", "--quiet", "--platform=linux/amd64,linux/arm64", testutil.AlpineImage)
+	}
+	testCase.Cleanup = func(data test.Data, helpers test.Helpers) {
+		helpers.Anyhow("rmi", "-f", testutil.AlpineImage)
+	}
+	testCase.SubTests = []*test.Case{
+		{
+			Description: "tag-non-verbose",
+			Command:     test.Command("manifest", "inspect", testutil.AlpineImage),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				index, ok := arr[0]["Index"].(map[string]interface{})
+				assert.Assert(t, ok)
+				manifests, ok := index["manifests"].([]interface{})
+				assert.Assert(t, ok)
+				assert.Assert(t, len(manifests) > 0)
+			}),
+		},
+		{
+			Description: "tag-verbose",
+			Command:     test.Command("manifest", "inspect", testutil.AlpineImage, "--verbose"),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				indexDesc := arr[0]["IndexDesc"].(map[string]interface{})
+				assert.Equal(t, indexDesc["mediaType"], "application/vnd.docker.distribution.manifest.list.v2+json")
+				assert.Equal(t, indexDesc["digest"], alpineDigest)
+				manifests, ok := arr[0]["Manifests"].([]interface{})
+				assert.Assert(t, ok, "should have Manifests field")
+				assert.Assert(t, len(manifests) > 0)
+				manifestObj, ok := manifests[0].(map[string]interface{})
+				assert.Assert(t, ok, "Manifests[0] should be object")
+				manifestArr := []map[string]interface{}{manifestObj}
+				assertManifestConfigDigest(t, manifestArr, alpineAmd64ConfigDigest)
+				assertManifestDescDigest(t, manifestArr, alpineAmd64Digest)
+			}),
+		},
+		{
+			Description: "digest-non-verbose",
+			Command:     test.Command("manifest", "inspect", "alpine@"+alpineAmd64Digest),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				assertManifestConfigDigest(t, arr, alpineAmd64ConfigDigest)
+			}),
+		},
+		{
+			Description: "digest-verbose",
+			Command:     test.Command("manifest", "inspect", "alpine@"+alpineAmd64Digest, "--verbose"),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				assertManifestConfigDigest(t, arr, alpineAmd64ConfigDigest)
+				assertManifestDescDigest(t, arr, alpineAmd64Digest)
+			}),
+		},
+		{
+			Description: "sha256-digest-non-verbose",
+			Command:     test.Command("manifest", "inspect", alpineAmd64Digest),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				assertManifestConfigDigest(t, arr, alpineAmd64ConfigDigest)
+			}),
+		},
+		{
+			Description: "sha256-digest-verbose",
+			Command:     test.Command("manifest", "inspect", alpineAmd64Digest, "--verbose"),
+			Expected: test.Expects(0, nil, func(stdout string, t tig.T) {
+				var arr []map[string]interface{}
+				assert.NilError(t, json.Unmarshal([]byte(stdout), &arr))
+				assert.Assert(t, len(arr) > 0)
+				assertManifestConfigDigest(t, arr, alpineAmd64ConfigDigest)
+				assertManifestDescDigest(t, arr, alpineAmd64Digest)
+			}),
+		},
+	}
+
+	testCase.Run(t)
+}
+
+func assertManifestConfigDigest(t tig.T, arr []map[string]interface{}, wantDigest string) {
+	manifest, ok := arr[0]["Manifest"].(map[string]interface{})
+	assert.Assert(t, ok)
+	config, ok := manifest["config"].(map[string]interface{})
+	assert.Assert(t, ok, "should have config field")
+	assert.Equal(t, config["digest"], wantDigest)
+}
+
+func assertManifestDescDigest(t tig.T, arr []map[string]interface{}, wantDigest string) {
+	manifestDesc, ok := arr[0]["ManifestDesc"].(map[string]interface{})
+	assert.Assert(t, ok, "should have ManifestDesc field")
+	assert.Equal(t, manifestDesc["digest"], wantDigest)
+}

cmd/nerdctl/manifest/manifest_test.go

@@ -0,0 +1,27 @@
+/*
+   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 manifest
+
+import (
+	"testing"
+
+	"github.com/containerd/nerdctl/v2/pkg/testutil"
+)
+
+func TestMain(m *testing.M) {
+	testutil.M(m)
+}

pkg/testutil/images.yaml

@@ -7,6 +7,10 @@ alpine:
   tag: "3.13-org"
   digest: "sha256:ec14c7992a97fc11425907e908340c6c3d6ff602f5f13d899e6b7027c9b4133a"
   variants: ["linux/amd64", "linux/arm64"]
+  platformDigests:
+    linux/amd64:
+      configDigest: "sha256:49f356fa4513676c5e22e3a8404aad6c7262cc7aaed15341458265320786c58c"
+      manifestDigest: "sha256:e103c1b4bf019dc290bcc7aca538dc2bf7a9d0fc836e186f5fa34945c5168310"
 
 busybox:
   ref: "ghcr.io/containerd/busybox"

pkg/testutil/images_linux.go

@@ -29,30 +29,61 @@ var rawImagesList string
 
 var testImagesOnce sync.Once
 
+type PlatformDigest struct {
+	Config   string `yaml:"config,omitempty"`
+	Manifest string `yaml:"manifest,omitempty"`
+}
+
 type TestImage struct {
-	Ref      string   `yaml:"ref"`
-	Tag      string   `yaml:"tag,omitempty"`
-	Digest   string   `yaml:"digest,omitempty"`
-	Variants []string `yaml:"variants,omitempty"`
+	Ref             string                    `yaml:"ref"`
+	Tag             string                    `yaml:"tag,omitempty"`
+	Digest          string                    `yaml:"digest,omitempty"`
+	Variants        []string                  `yaml:"variants,omitempty"`
+	PlatformDigests map[string]PlatformDigest `yaml:"platformDigests,omitempty"`
 }
 
 var testImages map[string]TestImage
 
-func getImage(key string) string {
+// internal helper to lookup TestImage by key, panics if not found
+func lookup(key string) TestImage {
 	testImagesOnce.Do(func() {
 		if err := yaml.Unmarshal([]byte(rawImagesList), &testImages); err != nil {
 			fmt.Printf("Error unmarshaling test images YAML file: %v\n", err)
 			panic("testing is broken")
 		}
 	})
-
-	var im TestImage
-	var ok bool
-
-	if im, ok = testImages[key]; !ok {
+	im, ok := testImages[key]
+	if !ok {
 		fmt.Printf("Image %s was not found in images list\n", key)
 		panic("testing is broken")
 	}
+	return im
+}
 
+func getImage(key string) string {
+	im := lookup(key)
 	return im.Ref + ":" + im.Tag
 }
+
+func GetTestImageConfigDigest(key, platform string) string {
+	im := lookup(key)
+	pd, ok := im.PlatformDigests[platform]
+	if !ok {
+		panic(fmt.Sprintf("platform %s not found for image %s", platform, key))
+	}
+	return pd.Config
+}
+
+func GetTestImageManifestDigest(key, platform string) string {
+	im := lookup(key)
+	pd, ok := im.PlatformDigests[platform]
+	if !ok {
+		panic(fmt.Sprintf("platform %s not found for image %s", platform, key))
+	}
+	return pd.Manifest
+}
+
+func GetTestImageDigest(key string) string {
+	im := lookup(key)
+	return im.Digest
+}