github.com/toplink-cn/moby@v0.0.0-20240305205811-460b4aebdf81/image/store_test.go (about)

     1  package image // import "github.com/docker/docker/image"
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/docker/docker/errdefs"
     8  	"github.com/docker/docker/layer"
     9  	"gotest.tools/v3/assert"
    10  	is "gotest.tools/v3/assert/cmp"
    11  )
    12  
    13  func TestCreate(t *testing.T) {
    14  	imgStore, cleanup := defaultImageStore(t)
    15  	defer cleanup()
    16  
    17  	_, err := imgStore.Create([]byte(`{}`))
    18  	assert.Check(t, is.Error(err, "invalid image JSON, no RootFS key"))
    19  }
    20  
    21  func TestRestore(t *testing.T) {
    22  	fs, cleanup := defaultFSStoreBackend(t)
    23  	defer cleanup()
    24  
    25  	id1, err := fs.Set([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
    26  	assert.NilError(t, err)
    27  
    28  	_, err = fs.Set([]byte(`invalid`))
    29  	assert.NilError(t, err)
    30  
    31  	id2, err := fs.Set([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
    32  	assert.NilError(t, err)
    33  
    34  	err = fs.SetMetadata(id2, "parent", []byte(id1))
    35  	assert.NilError(t, err)
    36  
    37  	imgStore, err := NewImageStore(fs, &mockLayerGetReleaser{})
    38  	assert.NilError(t, err)
    39  
    40  	assert.Check(t, is.Len(imgStore.Map(), 2))
    41  
    42  	img1, err := imgStore.Get(ID(id1))
    43  	assert.NilError(t, err)
    44  	assert.Check(t, is.Equal(ID(id1), img1.computedID))
    45  	assert.Check(t, is.Equal(string(id1), img1.computedID.String()))
    46  
    47  	img2, err := imgStore.Get(ID(id2))
    48  	assert.NilError(t, err)
    49  	assert.Check(t, is.Equal("abc", img1.Comment))
    50  	assert.Check(t, is.Equal("def", img2.Comment))
    51  
    52  	_, err = imgStore.GetParent(ID(id1))
    53  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
    54  	assert.ErrorContains(t, err, "failed to read metadata")
    55  
    56  	p, err := imgStore.GetParent(ID(id2))
    57  	assert.NilError(t, err)
    58  	assert.Check(t, is.Equal(ID(id1), p))
    59  
    60  	children := imgStore.Children(ID(id1))
    61  	assert.Check(t, is.Len(children, 1))
    62  	assert.Check(t, is.Equal(ID(id2), children[0]))
    63  	assert.Check(t, is.Len(imgStore.Heads(), 1))
    64  
    65  	sid1, err := imgStore.Search(string(id1)[:10])
    66  	assert.NilError(t, err)
    67  	assert.Check(t, is.Equal(ID(id1), sid1))
    68  
    69  	sid1, err = imgStore.Search(id1.Encoded()[:6])
    70  	assert.NilError(t, err)
    71  	assert.Check(t, is.Equal(ID(id1), sid1))
    72  
    73  	invalidPattern := id1.Encoded()[1:6]
    74  	_, err = imgStore.Search(invalidPattern)
    75  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
    76  	assert.Check(t, is.ErrorContains(err, invalidPattern))
    77  }
    78  
    79  func TestAddDelete(t *testing.T) {
    80  	imgStore, cleanup := defaultImageStore(t)
    81  	defer cleanup()
    82  
    83  	id1, err := imgStore.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
    84  	assert.NilError(t, err)
    85  	assert.Check(t, is.Equal(ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1))
    86  
    87  	img, err := imgStore.Get(id1)
    88  	assert.NilError(t, err)
    89  	assert.Check(t, is.Equal("abc", img.Comment))
    90  
    91  	id2, err := imgStore.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
    92  	assert.NilError(t, err)
    93  
    94  	err = imgStore.SetParent(id2, id1)
    95  	assert.NilError(t, err)
    96  
    97  	pid1, err := imgStore.GetParent(id2)
    98  	assert.NilError(t, err)
    99  	assert.Check(t, is.Equal(pid1, id1))
   100  
   101  	_, err = imgStore.Delete(id1)
   102  	assert.NilError(t, err)
   103  
   104  	_, err = imgStore.Get(id1)
   105  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
   106  	assert.ErrorContains(t, err, "failed to get digest")
   107  
   108  	_, err = imgStore.Get(id2)
   109  	assert.NilError(t, err)
   110  
   111  	_, err = imgStore.GetParent(id2)
   112  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
   113  	assert.ErrorContains(t, err, "failed to read metadata")
   114  }
   115  
   116  func TestSearchAfterDelete(t *testing.T) {
   117  	imgStore, cleanup := defaultImageStore(t)
   118  	defer cleanup()
   119  
   120  	id, err := imgStore.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
   121  	assert.NilError(t, err)
   122  
   123  	id1, err := imgStore.Search(string(id)[:15])
   124  	assert.NilError(t, err)
   125  	assert.Check(t, is.Equal(id1, id))
   126  
   127  	_, err = imgStore.Delete(id)
   128  	assert.NilError(t, err)
   129  
   130  	_, err = imgStore.Search(string(id)[:15])
   131  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
   132  	assert.ErrorContains(t, err, "No such image")
   133  }
   134  
   135  func TestDeleteNotExisting(t *testing.T) {
   136  	imgStore, cleanup := defaultImageStore(t)
   137  	defer cleanup()
   138  
   139  	_, err := imgStore.Delete(ID("i_dont_exists"))
   140  	assert.Check(t, is.ErrorType(err, errdefs.IsNotFound))
   141  }
   142  
   143  func TestParentReset(t *testing.T) {
   144  	imgStore, cleanup := defaultImageStore(t)
   145  	defer cleanup()
   146  
   147  	id, err := imgStore.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
   148  	assert.NilError(t, err)
   149  
   150  	id2, err := imgStore.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`))
   151  	assert.NilError(t, err)
   152  
   153  	id3, err := imgStore.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`))
   154  	assert.NilError(t, err)
   155  
   156  	assert.Check(t, imgStore.SetParent(id, id2))
   157  	assert.Check(t, is.Len(imgStore.Children(id2), 1))
   158  
   159  	assert.Check(t, imgStore.SetParent(id, id3))
   160  	assert.Check(t, is.Len(imgStore.Children(id2), 0))
   161  	assert.Check(t, is.Len(imgStore.Children(id3), 1))
   162  }
   163  
   164  func defaultImageStore(t *testing.T) (Store, func()) {
   165  	fsBackend, cleanup := defaultFSStoreBackend(t)
   166  
   167  	store, err := NewImageStore(fsBackend, &mockLayerGetReleaser{})
   168  	assert.NilError(t, err)
   169  
   170  	return store, cleanup
   171  }
   172  
   173  func TestGetAndSetLastUpdated(t *testing.T) {
   174  	store, cleanup := defaultImageStore(t)
   175  	defer cleanup()
   176  
   177  	id, err := store.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
   178  	assert.NilError(t, err)
   179  
   180  	updated, err := store.GetLastUpdated(id)
   181  	assert.NilError(t, err)
   182  	assert.Check(t, is.Equal(updated.IsZero(), true))
   183  
   184  	assert.Check(t, store.SetLastUpdated(id))
   185  
   186  	updated, err = store.GetLastUpdated(id)
   187  	assert.NilError(t, err)
   188  	assert.Check(t, is.Equal(updated.IsZero(), false))
   189  }
   190  
   191  func TestStoreLen(t *testing.T) {
   192  	store, cleanup := defaultImageStore(t)
   193  	defer cleanup()
   194  
   195  	expected := 10
   196  	for i := 0; i < expected; i++ {
   197  		_, err := store.Create([]byte(fmt.Sprintf(`{"comment": "abc%d", "rootfs": {"type": "layers"}}`, i)))
   198  		assert.NilError(t, err)
   199  	}
   200  	numImages := store.Len()
   201  	assert.Equal(t, expected, numImages)
   202  	assert.Equal(t, len(store.Map()), numImages)
   203  }
   204  
   205  type mockLayerGetReleaser struct{}
   206  
   207  func (ls *mockLayerGetReleaser) Get(layer.ChainID) (layer.Layer, error) {
   208  	return nil, nil
   209  }
   210  
   211  func (ls *mockLayerGetReleaser) Release(layer.Layer) ([]layer.Metadata, error) {
   212  	return nil, nil
   213  }