github.com/cspotcode/docker-cli@v20.10.0-rc1.0.20201201121459-3faad7acc5b8+incompatible/cli/command/manifest/inspect_test.go (about)

     1  package manifest
     2  
     3  import (
     4  	"context"
     5  	"io/ioutil"
     6  	"os"
     7  	"testing"
     8  
     9  	"github.com/docker/cli/cli/manifest/store"
    10  	"github.com/docker/cli/cli/manifest/types"
    11  	manifesttypes "github.com/docker/cli/cli/manifest/types"
    12  	"github.com/docker/cli/internal/test"
    13  	"github.com/docker/distribution"
    14  	"github.com/docker/distribution/manifest/schema2"
    15  	"github.com/docker/distribution/reference"
    16  	digest "github.com/opencontainers/go-digest"
    17  	ocispec "github.com/opencontainers/image-spec/specs-go/v1"
    18  	"github.com/pkg/errors"
    19  	"gotest.tools/v3/assert"
    20  	is "gotest.tools/v3/assert/cmp"
    21  	"gotest.tools/v3/golden"
    22  )
    23  
    24  func newTempManifestStore(t *testing.T) (store.Store, func()) {
    25  	tmpdir, err := ioutil.TempDir("", "test-manifest-storage")
    26  	assert.NilError(t, err)
    27  
    28  	return store.NewStore(tmpdir), func() { os.RemoveAll(tmpdir) }
    29  }
    30  
    31  func ref(t *testing.T, name string) reference.Named {
    32  	named, err := reference.ParseNamed("example.com/" + name)
    33  	assert.NilError(t, err)
    34  	return named
    35  }
    36  
    37  func fullImageManifest(t *testing.T, ref reference.Named) types.ImageManifest {
    38  	man, err := schema2.FromStruct(schema2.Manifest{
    39  		Versioned: schema2.SchemaVersion,
    40  		Config: distribution.Descriptor{
    41  			Digest:    "sha256:7328f6f8b41890597575cbaadc884e7386ae0acc53b747401ebce5cf0d624560",
    42  			Size:      1520,
    43  			MediaType: schema2.MediaTypeImageConfig,
    44  		},
    45  		Layers: []distribution.Descriptor{
    46  			{
    47  				MediaType: schema2.MediaTypeLayer,
    48  				Size:      1990402,
    49  				Digest:    "sha256:88286f41530e93dffd4b964e1db22ce4939fffa4a4c665dab8591fbab03d4926",
    50  			},
    51  		},
    52  	})
    53  	assert.NilError(t, err)
    54  
    55  	// TODO: include image data for verbose inspect
    56  	mt, raw, err := man.Payload()
    57  	assert.NilError(t, err)
    58  
    59  	desc := ocispec.Descriptor{
    60  		Digest:    digest.FromBytes(raw),
    61  		Size:      int64(len(raw)),
    62  		MediaType: mt,
    63  		Platform: &ocispec.Platform{
    64  			Architecture: "amd64",
    65  			OS:           "linux",
    66  		},
    67  	}
    68  
    69  	return types.NewImageManifest(ref, desc, man)
    70  }
    71  
    72  func TestInspectCommandLocalManifestNotFound(t *testing.T) {
    73  	store, cleanup := newTempManifestStore(t)
    74  	defer cleanup()
    75  
    76  	cli := test.NewFakeCli(nil)
    77  	cli.SetManifestStore(store)
    78  
    79  	cmd := newInspectCommand(cli)
    80  	cmd.SetOut(ioutil.Discard)
    81  	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
    82  	err := cmd.Execute()
    83  	assert.Error(t, err, "No such manifest: example.com/alpine:3.0")
    84  }
    85  
    86  func TestInspectCommandNotFound(t *testing.T) {
    87  	store, cleanup := newTempManifestStore(t)
    88  	defer cleanup()
    89  
    90  	cli := test.NewFakeCli(nil)
    91  	cli.SetManifestStore(store)
    92  	cli.SetRegistryClient(&fakeRegistryClient{
    93  		getManifestFunc: func(_ context.Context, _ reference.Named) (manifesttypes.ImageManifest, error) {
    94  			return manifesttypes.ImageManifest{}, errors.New("missing")
    95  		},
    96  		getManifestListFunc: func(ctx context.Context, ref reference.Named) ([]manifesttypes.ImageManifest, error) {
    97  			return nil, errors.Errorf("No such manifest: %s", ref)
    98  		},
    99  	})
   100  
   101  	cmd := newInspectCommand(cli)
   102  	cmd.SetOut(ioutil.Discard)
   103  	cmd.SetArgs([]string{"example.com/alpine:3.0"})
   104  	err := cmd.Execute()
   105  	assert.Error(t, err, "No such manifest: example.com/alpine:3.0")
   106  }
   107  
   108  func TestInspectCommandLocalManifest(t *testing.T) {
   109  	store, cleanup := newTempManifestStore(t)
   110  	defer cleanup()
   111  
   112  	cli := test.NewFakeCli(nil)
   113  	cli.SetManifestStore(store)
   114  	namedRef := ref(t, "alpine:3.0")
   115  	imageManifest := fullImageManifest(t, namedRef)
   116  	err := store.Save(ref(t, "list:v1"), namedRef, imageManifest)
   117  	assert.NilError(t, err)
   118  
   119  	cmd := newInspectCommand(cli)
   120  	cmd.SetArgs([]string{"example.com/list:v1", "example.com/alpine:3.0"})
   121  	assert.NilError(t, cmd.Execute())
   122  	actual := cli.OutBuffer()
   123  	expected := golden.Get(t, "inspect-manifest.golden")
   124  	assert.Check(t, is.Equal(string(expected), actual.String()))
   125  }
   126  
   127  func TestInspectcommandRemoteManifest(t *testing.T) {
   128  	store, cleanup := newTempManifestStore(t)
   129  	defer cleanup()
   130  
   131  	cli := test.NewFakeCli(nil)
   132  	cli.SetManifestStore(store)
   133  	cli.SetRegistryClient(&fakeRegistryClient{
   134  		getManifestFunc: func(_ context.Context, ref reference.Named) (manifesttypes.ImageManifest, error) {
   135  			return fullImageManifest(t, ref), nil
   136  		},
   137  	})
   138  
   139  	cmd := newInspectCommand(cli)
   140  	cmd.SetOut(ioutil.Discard)
   141  	cmd.SetArgs([]string{"example.com/alpine:3.0"})
   142  	assert.NilError(t, cmd.Execute())
   143  	actual := cli.OutBuffer()
   144  	expected := golden.Get(t, "inspect-manifest.golden")
   145  	assert.Check(t, is.Equal(string(expected), actual.String()))
   146  }