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

     1  package store
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"testing"
     7  
     8  	"github.com/docker/cli/cli/manifest/types"
     9  	"github.com/docker/distribution/reference"
    10  	"github.com/google/go-cmp/cmp"
    11  	"gotest.tools/v3/assert"
    12  	is "gotest.tools/v3/assert/cmp"
    13  )
    14  
    15  type fakeRef struct {
    16  	name string
    17  }
    18  
    19  func (f fakeRef) String() string {
    20  	return f.name
    21  }
    22  
    23  func (f fakeRef) Name() string {
    24  	return f.name
    25  }
    26  
    27  func ref(name string) fakeRef {
    28  	return fakeRef{name: name}
    29  }
    30  
    31  func sref(t *testing.T, name string) *types.SerializableNamed {
    32  	named, err := reference.ParseNamed("example.com/" + name)
    33  	assert.NilError(t, err)
    34  	return &types.SerializableNamed{Named: named}
    35  }
    36  
    37  func newTestStore(t *testing.T) (Store, func()) {
    38  	tmpdir, err := ioutil.TempDir("", "manifest-store-test")
    39  	assert.NilError(t, err)
    40  
    41  	return NewStore(tmpdir), func() { os.RemoveAll(tmpdir) }
    42  }
    43  
    44  func getFiles(t *testing.T, store Store) []os.FileInfo {
    45  	infos, err := ioutil.ReadDir(store.(*fsStore).root)
    46  	assert.NilError(t, err)
    47  	return infos
    48  }
    49  
    50  func TestStoreRemove(t *testing.T) {
    51  	store, cleanup := newTestStore(t)
    52  	defer cleanup()
    53  
    54  	listRef := ref("list")
    55  	data := types.ImageManifest{Ref: sref(t, "abcdef")}
    56  	assert.NilError(t, store.Save(listRef, ref("manifest"), data))
    57  	assert.Assert(t, is.Len(getFiles(t, store), 1))
    58  
    59  	assert.Check(t, store.Remove(listRef))
    60  	assert.Check(t, is.Len(getFiles(t, store), 0))
    61  }
    62  
    63  func TestStoreSaveAndGet(t *testing.T) {
    64  	store, cleanup := newTestStore(t)
    65  	defer cleanup()
    66  
    67  	listRef := ref("list")
    68  	data := types.ImageManifest{Ref: sref(t, "abcdef")}
    69  	err := store.Save(listRef, ref("exists"), data)
    70  	assert.NilError(t, err)
    71  
    72  	var testcases = []struct {
    73  		listRef     reference.Reference
    74  		manifestRef reference.Reference
    75  		expected    types.ImageManifest
    76  		expectedErr string
    77  	}{
    78  		{
    79  			listRef:     listRef,
    80  			manifestRef: ref("exists"),
    81  			expected:    data,
    82  		},
    83  		{
    84  			listRef:     listRef,
    85  			manifestRef: ref("exist:does-not"),
    86  			expectedErr: "No such manifest: exist:does-not",
    87  		},
    88  		{
    89  			listRef:     ref("list:does-not-exist"),
    90  			manifestRef: ref("manifest:does-not-exist"),
    91  			expectedErr: "No such manifest: manifest:does-not-exist",
    92  		},
    93  	}
    94  
    95  	for _, testcase := range testcases {
    96  		testcase := testcase
    97  		t.Run(testcase.manifestRef.String(), func(t *testing.T) {
    98  			actual, err := store.Get(testcase.listRef, testcase.manifestRef)
    99  			if testcase.expectedErr != "" {
   100  				assert.Error(t, err, testcase.expectedErr)
   101  				assert.Check(t, IsNotFound(err))
   102  				return
   103  			}
   104  			assert.NilError(t, err)
   105  			assert.DeepEqual(t, testcase.expected, actual, cmpReferenceNamed)
   106  		})
   107  	}
   108  }
   109  
   110  var cmpReferenceNamed = cmp.Transformer("namedref", func(r reference.Named) string {
   111  	return r.String()
   112  })
   113  
   114  func TestStoreGetList(t *testing.T) {
   115  	store, cleanup := newTestStore(t)
   116  	defer cleanup()
   117  
   118  	listRef := ref("list")
   119  	first := types.ImageManifest{Ref: sref(t, "first")}
   120  	assert.NilError(t, store.Save(listRef, ref("first"), first))
   121  	second := types.ImageManifest{Ref: sref(t, "second")}
   122  	assert.NilError(t, store.Save(listRef, ref("exists"), second))
   123  
   124  	list, err := store.GetList(listRef)
   125  	assert.NilError(t, err)
   126  	assert.Check(t, is.Len(list, 2))
   127  }
   128  
   129  func TestStoreGetListDoesNotExist(t *testing.T) {
   130  	store, cleanup := newTestStore(t)
   131  	defer cleanup()
   132  
   133  	listRef := ref("list")
   134  	_, err := store.GetList(listRef)
   135  	assert.Error(t, err, "No such manifest: list")
   136  	assert.Check(t, IsNotFound(err))
   137  }