use consistent alias for gotest.tools/v3/assert/cmp

Make sure we use the same alias everywhere for easier finding,
and to prevent accidentally introducing duplicate imports with
different aliases for the same package.

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
(cherry picked from commit f6b695d2fbe37cf850250f2f9003d0c941e4a7bc)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

daemon/images/store_test.go

@@ -17,7 +17,7 @@ import (
 	v1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"go.etcd.io/bbolt"
 	"gotest.tools/v3/assert"
-	"gotest.tools/v3/assert/cmp"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 func setupTestStores(t *testing.T) (context.Context, content.Store, *imageStoreWithLease, func(t *testing.T)) {
@@ -75,24 +75,24 @@ func TestImageDelete(t *testing.T) {
 
 		ls, err := images.leases.List(ctx)
 		assert.NilError(t, err)
-		assert.Check(t, cmp.Equal(len(ls), 1), ls)
+		assert.Check(t, is.Equal(len(ls), 1), ls)
 
 		_, err = images.Delete(id)
 		assert.NilError(t, err)
 
 		ls, err = images.leases.List(ctx)
 		assert.NilError(t, err)
-		assert.Check(t, cmp.Equal(len(ls), 0), ls)
+		assert.Check(t, is.Equal(len(ls), 0), ls)
 	})
 }
 
 func TestContentStoreForPull(t *testing.T) {
-	ctx, cs, is, cleanup := setupTestStores(t)
+	ctx, cs, imgStore, cleanup := setupTestStores(t)
 	defer cleanup(t)
 
 	csP := &contentStoreForPull{
 		ContentStore: cs,
-		leases:       is.leases,
+		leases:       imgStore.leases,
 	}
 
 	data := []byte(`{}`)
@@ -112,12 +112,12 @@ func TestContentStoreForPull(t *testing.T) {
 	assert.NilError(t, err)
 
 	assert.Equal(t, len(csP.digested), 1)
-	assert.Check(t, cmp.Equal(csP.digested[0], desc.Digest))
+	assert.Check(t, is.Equal(csP.digested[0], desc.Digest))
 
 	// Test already exists
 	csP.digested = nil
 	_, err = csP.Writer(ctx, content.WithRef(t.Name()), content.WithDescriptor(desc))
 	assert.Check(t, c8derrdefs.IsAlreadyExists(err))
 	assert.Equal(t, len(csP.digested), 1)
-	assert.Check(t, cmp.Equal(csP.digested[0], desc.Digest))
+	assert.Check(t, is.Equal(csP.digested[0], desc.Digest))
 }

daemon/logger/loggerutils/cache/log_cache_test.go

@@ -1,16 +1,14 @@
 package cache
 
 import (
+	"bytes"
 	"context"
 	"testing"
-
 	"time"
 
-	"bytes"
-
 	"github.com/docker/docker/daemon/logger"
 	"gotest.tools/v3/assert"
-	"gotest.tools/v3/assert/cmp"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 type fakeLogger struct {
@@ -75,7 +73,7 @@ func TestLog(t *testing.T) {
 		case <-ctx.Done():
 			t.Fatal("timed out waiting for messages... this is probably a test implementation error")
 		case msg = <-cacher.messages:
-			assert.Assert(t, cmp.DeepEqual(msg, m))
+			assert.Assert(t, is.DeepEqual(msg, m))
 		}
 	}
 }

daemon/logger/loggerutils/sharedtemp_test.go

@@ -14,7 +14,7 @@ import (
 
 	"github.com/pkg/errors"
 	"gotest.tools/v3/assert"
-	"gotest.tools/v3/assert/cmp"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 func TestSharedTempFileConverter(t *testing.T) {
@@ -33,9 +33,9 @@ func TestSharedTempFileConverter(t *testing.T) {
 			t.Logf("Iteration %v", i)
 
 			rdr := convertPath(t, uut, name)
-			assert.Check(t, cmp.Equal("HELLO, WORLD!", readAll(t, rdr)))
+			assert.Check(t, is.Equal("HELLO, WORLD!", readAll(t, rdr)))
 			assert.Check(t, rdr.Close())
-			assert.Check(t, cmp.Equal(fs.ErrClosed, rdr.Close()), "closing an already-closed reader should return an error")
+			assert.Check(t, is.Equal(fs.ErrClosed, rdr.Close()), "closing an already-closed reader should return an error")
 		}
 
 		assert.NilError(t, os.Remove(name))
@@ -67,15 +67,15 @@ func TestSharedTempFileConverter(t *testing.T) {
 
 		rb1 := convertPath(t, uut, bpath) // Same path, different file.
 		ra2 := convertPath(t, uut, apath) // New path, old file.
-		assert.Check(t, cmp.Equal(2, conversions), "expected only one conversion per unique file")
+		assert.Check(t, is.Equal(2, conversions), "expected only one conversion per unique file")
 
 		// Interleave reading and closing to shake out ref-counting bugs:
 		// closing one reader shouldn't affect any other open readers.
-		assert.Check(t, cmp.Equal("FILE A", readAll(t, ra1)))
+		assert.Check(t, is.Equal("FILE A", readAll(t, ra1)))
 		assert.NilError(t, ra1.Close())
-		assert.Check(t, cmp.Equal("FILE A", readAll(t, ra2)))
+		assert.Check(t, is.Equal("FILE A", readAll(t, ra2)))
 		assert.NilError(t, ra2.Close())
-		assert.Check(t, cmp.Equal("FILE B", readAll(t, rb1)))
+		assert.Check(t, is.Equal("FILE B", readAll(t, rb1)))
 		assert.NilError(t, rb1.Close())
 
 		assert.NilError(t, os.Remove(apath))
@@ -120,7 +120,7 @@ func TestSharedTempFileConverter(t *testing.T) {
 				t.Logf("goroutine %v: enter", i)
 				defer t.Logf("goroutine %v: exit", i)
 				f := convertPath(t, uut, name)
-				assert.Check(t, cmp.Equal("HI THERE", readAll(t, f)), "in goroutine %v", i)
+				assert.Check(t, is.Equal("HI THERE", readAll(t, f)), "in goroutine %v", i)
 				closers <- f
 			}()
 		}
@@ -138,12 +138,12 @@ func TestSharedTempFileConverter(t *testing.T) {
 		f := convertPath(t, uut, name)
 		closers <- f
 		close(closers)
-		assert.Check(t, cmp.Equal("HI THERE", readAll(t, f)), "after all goroutines returned")
+		assert.Check(t, is.Equal("HI THERE", readAll(t, f)), "after all goroutines returned")
 		for c := range closers {
 			assert.Check(t, c.Close())
 		}
 
-		assert.Check(t, cmp.Equal(int32(1), conversions))
+		assert.Check(t, is.Equal(int32(1), conversions))
 
 		assert.NilError(t, os.Remove(name))
 		checkDirEmpty(t, dir)
@@ -197,7 +197,7 @@ func TestSharedTempFileConverter(t *testing.T) {
 		fakeErr = nil
 		f, err := uut.Do(src)
 		assert.Check(t, err)
-		assert.Check(t, cmp.Equal("HI THERE", readAll(t, f)))
+		assert.Check(t, is.Equal("HI THERE", readAll(t, f)))
 		assert.Check(t, f.Close())
 
 		// Files pending delete continue to show up in directory
@@ -240,7 +240,7 @@ func checkDirEmpty(t *testing.T, path string) {
 	t.Helper()
 	ls, err := os.ReadDir(path)
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Len(ls, 0), "directory should be free of temp files")
+	assert.Check(t, is.Len(ls, 0), "directory should be free of temp files")
 }
 
 func copyTransform(f func(string) string) func(dst io.WriteSeeker, src io.ReadSeeker) error {

image/store_test.go

@@ -6,15 +6,15 @@ import (
 
 	"github.com/docker/docker/layer"
 	"gotest.tools/v3/assert"
-	"gotest.tools/v3/assert/cmp"
+	is "gotest.tools/v3/assert/cmp"
 )
 
 func TestCreate(t *testing.T) {
-	is, cleanup := defaultImageStore(t)
+	imgStore, cleanup := defaultImageStore(t)
 	defer cleanup()
 
-	_, err := is.Create([]byte(`{}`))
-	assert.Check(t, cmp.Error(err, "invalid image JSON, no RootFS key"))
+	_, err := imgStore.Create([]byte(`{}`))
+	assert.Check(t, is.Error(err, "invalid image JSON, no RootFS key"))
 }
 
 func TestRestore(t *testing.T) {
@@ -33,118 +33,118 @@ func TestRestore(t *testing.T) {
 	err = fs.SetMetadata(id2, "parent", []byte(id1))
 	assert.NilError(t, err)
 
-	is, err := NewImageStore(fs, &mockLayerGetReleaser{})
+	imgStore, err := NewImageStore(fs, &mockLayerGetReleaser{})
 	assert.NilError(t, err)
 
-	assert.Check(t, cmp.Len(is.Map(), 2))
+	assert.Check(t, is.Len(imgStore.Map(), 2))
 
-	img1, err := is.Get(ID(id1))
+	img1, err := imgStore.Get(ID(id1))
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(ID(id1), img1.computedID))
-	assert.Check(t, cmp.Equal(string(id1), img1.computedID.String()))
+	assert.Check(t, is.Equal(ID(id1), img1.computedID))
+	assert.Check(t, is.Equal(string(id1), img1.computedID.String()))
 
-	img2, err := is.Get(ID(id2))
+	img2, err := imgStore.Get(ID(id2))
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal("abc", img1.Comment))
-	assert.Check(t, cmp.Equal("def", img2.Comment))
+	assert.Check(t, is.Equal("abc", img1.Comment))
+	assert.Check(t, is.Equal("def", img2.Comment))
 
-	_, err = is.GetParent(ID(id1))
+	_, err = imgStore.GetParent(ID(id1))
 	assert.ErrorContains(t, err, "failed to read metadata")
 
-	p, err := is.GetParent(ID(id2))
+	p, err := imgStore.GetParent(ID(id2))
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(ID(id1), p))
+	assert.Check(t, is.Equal(ID(id1), p))
 
-	children := is.Children(ID(id1))
-	assert.Check(t, cmp.Len(children, 1))
-	assert.Check(t, cmp.Equal(ID(id2), children[0]))
-	assert.Check(t, cmp.Len(is.Heads(), 1))
+	children := imgStore.Children(ID(id1))
+	assert.Check(t, is.Len(children, 1))
+	assert.Check(t, is.Equal(ID(id2), children[0]))
+	assert.Check(t, is.Len(imgStore.Heads(), 1))
 
-	sid1, err := is.Search(string(id1)[:10])
+	sid1, err := imgStore.Search(string(id1)[:10])
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(ID(id1), sid1))
+	assert.Check(t, is.Equal(ID(id1), sid1))
 
-	sid1, err = is.Search(id1.Hex()[:6])
+	sid1, err = imgStore.Search(id1.Hex()[:6])
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(ID(id1), sid1))
+	assert.Check(t, is.Equal(ID(id1), sid1))
 
 	invalidPattern := id1.Hex()[1:6]
-	_, err = is.Search(invalidPattern)
+	_, err = imgStore.Search(invalidPattern)
 	assert.ErrorContains(t, err, "No such image")
 }
 
 func TestAddDelete(t *testing.T) {
-	is, cleanup := defaultImageStore(t)
+	imgStore, cleanup := defaultImageStore(t)
 	defer cleanup()
 
-	id1, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
+	id1, err := imgStore.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1))
+	assert.Check(t, is.Equal(ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1))
 
-	img, err := is.Get(id1)
+	img, err := imgStore.Get(id1)
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal("abc", img.Comment))
+	assert.Check(t, is.Equal("abc", img.Comment))
 
-	id2, err := is.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
+	id2, err := imgStore.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
 	assert.NilError(t, err)
 
-	err = is.SetParent(id2, id1)
+	err = imgStore.SetParent(id2, id1)
 	assert.NilError(t, err)
 
-	pid1, err := is.GetParent(id2)
+	pid1, err := imgStore.GetParent(id2)
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(pid1, id1))
+	assert.Check(t, is.Equal(pid1, id1))
 
-	_, err = is.Delete(id1)
+	_, err = imgStore.Delete(id1)
 	assert.NilError(t, err)
 
-	_, err = is.Get(id1)
+	_, err = imgStore.Get(id1)
 	assert.ErrorContains(t, err, "failed to get digest")
 
-	_, err = is.Get(id2)
+	_, err = imgStore.Get(id2)
 	assert.NilError(t, err)
 
-	_, err = is.GetParent(id2)
+	_, err = imgStore.GetParent(id2)
 	assert.ErrorContains(t, err, "failed to read metadata")
 }
 
 func TestSearchAfterDelete(t *testing.T) {
-	is, cleanup := defaultImageStore(t)
+	imgStore, cleanup := defaultImageStore(t)
 	defer cleanup()
 
-	id, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
+	id, err := imgStore.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
 	assert.NilError(t, err)
 
-	id1, err := is.Search(string(id)[:15])
+	id1, err := imgStore.Search(string(id)[:15])
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(id1, id))
+	assert.Check(t, is.Equal(id1, id))
 
-	_, err = is.Delete(id)
+	_, err = imgStore.Delete(id)
 	assert.NilError(t, err)
 
-	_, err = is.Search(string(id)[:15])
+	_, err = imgStore.Search(string(id)[:15])
 	assert.ErrorContains(t, err, "No such image")
 }
 
 func TestParentReset(t *testing.T) {
-	is, cleanup := defaultImageStore(t)
+	imgStore, cleanup := defaultImageStore(t)
 	defer cleanup()
 
-	id, err := is.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
+	id, err := imgStore.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
 	assert.NilError(t, err)
 
-	id2, err := is.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`))
+	id2, err := imgStore.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`))
 	assert.NilError(t, err)
 
-	id3, err := is.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`))
+	id3, err := imgStore.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`))
 	assert.NilError(t, err)
 
-	assert.Check(t, is.SetParent(id, id2))
-	assert.Check(t, cmp.Len(is.Children(id2), 1))
+	assert.Check(t, imgStore.SetParent(id, id2))
+	assert.Check(t, is.Len(imgStore.Children(id2), 1))
 
-	assert.Check(t, is.SetParent(id, id3))
-	assert.Check(t, cmp.Len(is.Children(id2), 0))
-	assert.Check(t, cmp.Len(is.Children(id3), 1))
+	assert.Check(t, imgStore.SetParent(id, id3))
+	assert.Check(t, is.Len(imgStore.Children(id2), 0))
+	assert.Check(t, is.Len(imgStore.Children(id3), 1))
 }
 
 func defaultImageStore(t *testing.T) (Store, func()) {
@@ -165,13 +165,13 @@ func TestGetAndSetLastUpdated(t *testing.T) {
 
 	updated, err := store.GetLastUpdated(id)
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(updated.IsZero(), true))
+	assert.Check(t, is.Equal(updated.IsZero(), true))
 
 	assert.Check(t, store.SetLastUpdated(id))
 
 	updated, err = store.GetLastUpdated(id)
 	assert.NilError(t, err)
-	assert.Check(t, cmp.Equal(updated.IsZero(), false))
+	assert.Check(t, is.Equal(updated.IsZero(), false))
 }
 
 func TestStoreLen(t *testing.T) {