github/containerd
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

Use testify

Browse Source 
Signed-off-by: Maksym Pavlenko <pavlenko.maksym@gmail.com>
This commit is contained in:
Maksym Pavlenko
2022-04-01 18:17:58 -07:00
parent 9766107a53
commit 871b6b6a9f
30 changed files with 356 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
snapshots/devmapper/config_test.go
View File

@@ -25,8 +25,7 @@ import (
"github.com/hashicorp/go-multierror"
"github.com/pelletier/go-toml"
"gotest.tools/v3/assert"
is "gotest.tools/v3/assert/cmp"
"github.com/stretchr/testify/assert"
)
func TestLoadConfig(t *testing.T) {
@@ -37,28 +36,27 @@ func TestLoadConfig(t *testing.T) {
}
file, err := os.CreateTemp("", "devmapper-config-")
assert.NilError(t, err)
assert.NoError(t, err)
encoder := toml.NewEncoder(file)
err = encoder.Encode(&expected)
assert.NilError(t, err)
assert.NoError(t, err)
defer func() {
err := file.Close()
assert.NilError(t, err)
assert.NoError(t, err)
err = os.Remove(file.Name())
assert.NilError(t, err)
assert.NoError(t, err)
}()
loaded, err := LoadConfig(file.Name())
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, loaded.RootPath, expected.RootPath)
assert.Equal(t, loaded.PoolName, expected.PoolName)
assert.Equal(t, loaded.BaseImageSize, expected.BaseImageSize)
assert.Assert(t, loaded.BaseImageSizeBytes == 128*1024*1024)
assert.True(t, loaded.BaseImageSizeBytes == 128*1024*1024)
}
func TestLoadConfigInvalidPath(t *testing.T) {
@@ -66,7 +64,7 @@ func TestLoadConfigInvalidPath(t *testing.T) {
assert.Equal(t, os.ErrNotExist, err)
_, err = LoadConfig("/dev/null")
assert.Assert(t, err != nil)
assert.NotNil(t, err)
}
func TestParseInvalidData(t *testing.T) {
@@ -81,15 +79,15 @@ func TestParseInvalidData(t *testing.T) {
func TestFieldValidation(t *testing.T) {
config := &Config{}
err := config.Validate()
assert.Assert(t, err != nil)
assert.NotNil(t, err)
multErr := (err).(*multierror.Error)
assert.Assert(t, is.Len(multErr.Errors, 4))
assert.Len(t, multErr.Errors, 4)
assert.Assert(t, multErr.Errors[0] != nil, "pool_name is empty")
assert.Assert(t, multErr.Errors[1] != nil, "root_path is empty")
assert.Assert(t, multErr.Errors[2] != nil, "base_image_size is empty")
assert.Assert(t, multErr.Errors[3] != nil, "filesystem type cannot be empty")
assert.NotNil(t, multErr.Errors[0], "pool_name is empty")
assert.NotNil(t, multErr.Errors[1], "root_path is empty")
assert.NotNil(t, multErr.Errors[2], "base_image_size is empty")
assert.NotNil(t, multErr.Errors[3], "filesystem type cannot be empty")
}
func TestExistingPoolFieldValidation(t *testing.T) {
@@ -101,5 +99,5 @@ func TestExistingPoolFieldValidation(t *testing.T) {
}
err := config.Validate()
assert.NilError(t, err)
assert.NoError(t, err)
}

84
snapshots/devmapper/dmsetup/dmsetup_test.go
View File

@@ -24,13 +24,11 @@ import (
"strings"
"testing"
"github.com/docker/go-units"
"golang.org/x/sys/unix"
"gotest.tools/v3/assert"
is "gotest.tools/v3/assert/cmp"
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/pkg/testutil"
"github.com/docker/go-units"
"github.com/stretchr/testify/assert"
"golang.org/x/sys/unix"
)
const (
@@ -50,23 +48,23 @@ func TestDMSetup(t *testing.T) {
defer func() {
err := mount.DetachLoopDevice(loopDataDevice, loopMetaDevice)
assert.NilError(t, err, "failed to detach loop devices for data image: %s and meta image: %s", dataImage, metaImage)
assert.Nil(t, err, "failed to detach loop devices for data image: %s and meta image: %s", dataImage, metaImage)
}()
t.Run("CreatePool", func(t *testing.T) {
err := CreatePool(testPoolName, loopDataDevice, loopMetaDevice, 128)
assert.NilError(t, err, "failed to create thin-pool with %s %s", loopDataDevice, loopMetaDevice)
assert.Nil(t, err, "failed to create thin-pool with %s %s", loopDataDevice, loopMetaDevice)
table, err := Table(testPoolName)
t.Logf("table: %s", table)
assert.NilError(t, err)
assert.Assert(t, strings.HasPrefix(table, "0 32768 thin-pool"))
assert.Assert(t, strings.HasSuffix(table, "128 32768 1 skip_block_zeroing"))
assert.NoError(t, err)
assert.True(t, strings.HasPrefix(table, "0 32768 thin-pool"))
assert.True(t, strings.HasSuffix(table, "128 32768 1 skip_block_zeroing"))
})
t.Run("ReloadPool", func(t *testing.T) {
err := ReloadPool(testPoolName, loopDataDevice, loopMetaDevice, 256)
assert.NilError(t, err, "failed to reload thin-pool")
assert.Nil(t, err, "failed to reload thin-pool")
})
t.Run("CreateDevice", testCreateDevice)
@@ -82,7 +80,7 @@ func TestDMSetup(t *testing.T) {
t.Run("RemovePool", func(t *testing.T) {
err := RemoveDevice(testPoolName, RemoveWithForce, RemoveWithRetries)
assert.NilError(t, err, "failed to remove thin-pool")
assert.Nil(t, err, "failed to remove thin-pool")
})
t.Run("Version", testVersion)
@@ -90,116 +88,116 @@ func TestDMSetup(t *testing.T) {
func testCreateDevice(t *testing.T) {
err := CreateDevice(testPoolName, deviceID)
assert.NilError(t, err, "failed to create test device")
assert.Nil(t, err, "failed to create test device")
err = CreateDevice(testPoolName, deviceID)
assert.Assert(t, err == unix.EEXIST)
assert.True(t, err == unix.EEXIST)
infos, err := Info(testPoolName)
assert.NilError(t, err)
assert.Assert(t, is.Len(infos, 1), "got unexpected number of device infos")
assert.NoError(t, err)
assert.Len(t, infos, 1, "got unexpected number of device infos")
}
func testCreateSnapshot(t *testing.T) {
err := CreateSnapshot(testPoolName, snapshotID, deviceID)
assert.NilError(t, err)
assert.NoError(t, err)
}
func testDeleteSnapshot(t *testing.T) {
err := DeleteDevice(testPoolName, snapshotID)
assert.NilError(t, err, "failed to send delete message")
assert.Nil(t, err, "failed to send delete message")
err = DeleteDevice(testPoolName, snapshotID)
assert.Assert(t, err == unix.ENODATA)
assert.Equal(t, err, unix.ENODATA)
}
func testActivateDevice(t *testing.T) {
err := ActivateDevice(testPoolName, testDeviceName, 1, 1024, "")
assert.NilError(t, err, "failed to activate device")
assert.Nil(t, err, "failed to activate device")
err = ActivateDevice(testPoolName, testDeviceName, 1, 1024, "")
assert.Equal(t, err, unix.EBUSY)
if _, err := os.Stat("/dev/mapper/" + testDeviceName); err != nil && !os.IsExist(err) {
assert.NilError(t, err, "failed to stat device")
assert.Nil(t, err, "failed to stat device")
}
list, err := Info(testPoolName)
assert.NilError(t, err)
assert.Assert(t, is.Len(list, 1))
assert.NoError(t, err)
assert.Len(t, list, 1)
info := list[0]
assert.Equal(t, testPoolName, info.Name)
assert.Assert(t, info.TableLive)
assert.True(t, info.TableLive)
}
func testDeviceStatus(t *testing.T) {
status, err := Status(testDeviceName)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, int64(0), status.Offset)
assert.Equal(t, int64(2), status.Length)
assert.Equal(t, "thin", status.Target)
assert.DeepEqual(t, status.Params, []string{"0", "-"})
assert.Equal(t, status.Params, []string{"0", "-"})
}
func testSuspendResumeDevice(t *testing.T) {
err := SuspendDevice(testDeviceName)
assert.NilError(t, err)
assert.NoError(t, err)
err = SuspendDevice(testDeviceName)
assert.NilError(t, err)
assert.NoError(t, err)
list, err := Info(testDeviceName)
assert.NilError(t, err)
assert.Assert(t, is.Len(list, 1))
assert.NoError(t, err)
assert.Len(t, list, 1)
info := list[0]
assert.Assert(t, info.Suspended)
assert.True(t, info.Suspended)
err = ResumeDevice(testDeviceName)
assert.NilError(t, err)
assert.NoError(t, err)
err = ResumeDevice(testDeviceName)
assert.NilError(t, err)
assert.NoError(t, err)
}
func testDiscardBlocks(t *testing.T) {
err := DiscardBlocks(testDeviceName)
assert.NilError(t, err, "failed to discard blocks")
assert.Nil(t, err, "failed to discard blocks")
}
func testRemoveDevice(t *testing.T) {
err := RemoveDevice(testPoolName)
assert.Assert(t, err == unix.EBUSY, "removing thin-pool with dependencies shouldn't be allowed")
assert.Equal(t, err, unix.EBUSY, "removing thin-pool with dependencies shouldn't be allowed")
err = RemoveDevice(testDeviceName, RemoveWithRetries)
assert.NilError(t, err, "failed to remove thin-device")
assert.Nil(t, err, "failed to remove thin-device")
}
func testVersion(t *testing.T) {
version, err := Version()
assert.NilError(t, err)
assert.Assert(t, version != "")
assert.NoError(t, err)
assert.NotEmpty(t, version)
}
func createLoopbackDevice(t *testing.T, dir string) (string, string) {
file, err := os.CreateTemp(dir, "dmsetup-tests-")
assert.NilError(t, err)
assert.NoError(t, err)
size, err := units.RAMInBytes("16Mb")
assert.NilError(t, err)
assert.NoError(t, err)
err = file.Truncate(size)
assert.NilError(t, err)
assert.NoError(t, err)
err = file.Close()
assert.NilError(t, err)
assert.NoError(t, err)
imagePath := file.Name()
loopDevice, err := mount.AttachLoopDevice(imagePath)
assert.NilError(t, err)
assert.NoError(t, err)
return imagePath, loopDevice
}

67
snapshots/devmapper/metadata_test.go
View File

@@ -26,9 +26,8 @@ import (
"strconv"
"testing"
"github.com/stretchr/testify/assert"
"go.etcd.io/bbolt"
"gotest.tools/v3/assert"
is "gotest.tools/v3/assert/cmp"
)
var (
@@ -47,16 +46,16 @@ func TestPoolMetadata_AddDevice(t *testing.T) {
}
err := store.AddDevice(testCtx, expected)
assert.NilError(t, err)
assert.NoError(t, err)
result, err := store.GetDevice(testCtx, "test2")
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, expected.Name, result.Name)
assert.Equal(t, expected.ParentName, result.ParentName)
assert.Equal(t, expected.Size, result.Size)
assert.Equal(t, expected.State, result.State)
assert.Assert(t, result.DeviceID != 0)
assert.NotZero(t, result.DeviceID, 0)
assert.Equal(t, expected.DeviceID, result.DeviceID)
}
@@ -65,7 +64,7 @@ func TestPoolMetadata_AddDeviceRollback(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: ""})
assert.Assert(t, err != nil)
assert.True(t, err != nil)
_, err = store.GetDevice(testCtx, "")
assert.Equal(t, ErrNotFound, err)
@@ -76,10 +75,10 @@ func TestPoolMetadata_AddDeviceDuplicate(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: "test"})
assert.NilError(t, err)
assert.NoError(t, err)
err = store.AddDevice(testCtx, &DeviceInfo{Name: "test"})
assert.Assert(t, errors.Is(err, ErrAlreadyExists))
assert.True(t, errors.Is(err, ErrAlreadyExists))
}
func TestPoolMetadata_ReuseDeviceID(t *testing.T) {
@@ -88,21 +87,21 @@ func TestPoolMetadata_ReuseDeviceID(t *testing.T) {
info1 := &DeviceInfo{Name: "test1"}
err := store.AddDevice(testCtx, info1)
assert.NilError(t, err)
assert.NoError(t, err)
info2 := &DeviceInfo{Name: "test2"}
err = store.AddDevice(testCtx, info2)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Assert(t, info1.DeviceID != info2.DeviceID)
assert.Assert(t, info1.DeviceID != 0)
assert.NotEqual(t, info1.DeviceID, info2.DeviceID)
assert.NotZero(t, info1.DeviceID)
err = store.RemoveDevice(testCtx, info2.Name)
assert.NilError(t, err)
assert.NoError(t, err)
info3 := &DeviceInfo{Name: "test3"}
err = store.AddDevice(testCtx, info3)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, info2.DeviceID, info3.DeviceID)
}
@@ -112,10 +111,10 @@ func TestPoolMetadata_RemoveDevice(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: "test"})
assert.NilError(t, err)
assert.NoError(t, err)
err = store.RemoveDevice(testCtx, "test")
assert.NilError(t, err)
assert.NoError(t, err)
_, err = store.GetDevice(testCtx, "test")
assert.Equal(t, ErrNotFound, err)
@@ -133,7 +132,7 @@ func TestPoolMetadata_UpdateDevice(t *testing.T) {
}
err := store.AddDevice(testCtx, oldInfo)
assert.NilError(t, err)
assert.NoError(t, err)
err = store.UpdateDevice(testCtx, oldInfo.Name, func(info *DeviceInfo) error {
info.ParentName = "test5"
@@ -142,14 +141,14 @@ func TestPoolMetadata_UpdateDevice(t *testing.T) {
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
newInfo, err := store.GetDevice(testCtx, "test1")
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, "test1", newInfo.Name)
assert.Equal(t, "test5", newInfo.ParentName)
assert.Assert(t, newInfo.Size == 6)
assert.EqualValues(t, newInfo.Size, 6)
assert.Equal(t, Created, newInfo.State)
}
@@ -159,15 +158,15 @@ func TestPoolMetadata_MarkFaulty(t *testing.T) {
info := &DeviceInfo{Name: "test"}
err := store.AddDevice(testCtx, info)
assert.NilError(t, err)
assert.NoError(t, err)
err = store.MarkFaulty(testCtx, "test")
assert.NilError(t, err)
assert.NoError(t, err)
saved, err := store.GetDevice(testCtx, info.Name)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, saved.State, Faulty)
assert.Assert(t, saved.DeviceID > 0)
assert.True(t, saved.DeviceID > 0)
// Make sure a device ID marked as faulty as well
err = store.db.View(func(tx *bbolt.Tx) error {
@@ -177,7 +176,7 @@ func TestPoolMetadata_MarkFaulty(t *testing.T) {
assert.Equal(t, value[0], byte(deviceFaulty))
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
}
func TestPoolMetadata_WalkDevices(t *testing.T) {
@@ -185,10 +184,10 @@ func TestPoolMetadata_WalkDevices(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: "device1", DeviceID: 1, State: Created})
assert.NilError(t, err)
assert.NoError(t, err)
err = store.AddDevice(testCtx, &DeviceInfo{Name: "device2", DeviceID: 2, State: Faulty})
assert.NilError(t, err)
assert.NoError(t, err)
called := 0
err = store.WalkDevices(testCtx, func(info *DeviceInfo) error {
@@ -208,7 +207,7 @@ func TestPoolMetadata_WalkDevices(t *testing.T) {
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, called, 2)
}
@@ -217,14 +216,14 @@ func TestPoolMetadata_GetDeviceNames(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: "test1"})
assert.NilError(t, err)
assert.NoError(t, err)
err = store.AddDevice(testCtx, &DeviceInfo{Name: "test2"})
assert.NilError(t, err)
assert.NoError(t, err)
names, err := store.GetDeviceNames(testCtx)
assert.NilError(t, err)
assert.Assert(t, is.Len(names, 2))
assert.NoError(t, err)
assert.Len(t, names, 2)
assert.Equal(t, "test1", names[0])
assert.Equal(t, "test2", names[1])
@@ -233,12 +232,12 @@ func TestPoolMetadata_GetDeviceNames(t *testing.T) {
func createStore(t *testing.T) (store *PoolMetadata) {
path := filepath.Join(t.TempDir(), "test.db")
metadata, err := NewPoolMetadata(path)
assert.NilError(t, err)
assert.NoError(t, err)
return metadata
}
func cleanupStore(t *testing.T, store *PoolMetadata) {
err := store.Close()
assert.NilError(t, err, "failed to close metadata store")
assert.Nil(t, err, "failed to close metadata store")
}

80
snapshots/devmapper/pool_device_test.go
View File

@@ -32,8 +32,8 @@ import (
"github.com/containerd/containerd/snapshots/devmapper/dmsetup"
"github.com/docker/go-units"
"github.com/sirupsen/logrus"
"github.com/stretchr/testify/assert"
exec "golang.org/x/sys/execabs"
"gotest.tools/v3/assert"
)
const (
@@ -68,12 +68,12 @@ func TestPoolDevice(t *testing.T) {
poolName := fmt.Sprintf("test-pool-device-%d", time.Now().Nanosecond())
err := dmsetup.CreatePool(poolName, loopDataDevice, loopMetaDevice, 64*1024/dmsetup.SectorSize)
assert.NilError(t, err, "failed to create pool %q", poolName)
assert.Nil(t, err, "failed to create pool %q", poolName)
defer func() {
// Detach loop devices and remove images
err := mount.DetachLoopDevice(loopDataDevice, loopMetaDevice)
assert.NilError(t, err)
assert.NoError(t, err)
}()
config := &Config{
@@ -85,12 +85,12 @@ func TestPoolDevice(t *testing.T) {
}
pool, err := NewPoolDevice(ctx, config)
assert.NilError(t, err, "can't create device pool")
assert.Assert(t, pool != nil)
assert.Nil(t, err, "can't create device pool")
assert.True(t, pool != nil)
defer func() {
err := pool.RemovePool(ctx)
assert.NilError(t, err, "can't close device pool")
assert.Nil(t, err, "can't close device pool")
}()
// Create thin devices
@@ -108,7 +108,7 @@ func TestPoolDevice(t *testing.T) {
// Write v1 test file on 'thin-1' device
thin1TestFilePath := filepath.Join(thin1MountPath, "TEST")
err := os.WriteFile(thin1TestFilePath, []byte("test file (v1)"), 0700)
assert.NilError(t, err, "failed to write test file v1 on '%s' volume", thinDevice1)
assert.Nil(t, err, "failed to write test file v1 on '%s' volume", thinDevice1)
return nil
})
@@ -122,24 +122,24 @@ func TestPoolDevice(t *testing.T) {
err = mount.WithTempMount(ctx, getMounts(thinDevice1), func(thin1MountPath string) error {
thin1TestFilePath := filepath.Join(thin1MountPath, "TEST")
err = os.WriteFile(thin1TestFilePath, []byte("test file (v2)"), 0700)
assert.NilError(t, err, "failed to write test file v2 on 'thin-1' volume after taking snapshot")
assert.Nil(t, err, "failed to write test file v2 on 'thin-1' volume after taking snapshot")
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
// Mount 'snap-1' and make sure TEST file is v1
err = mount.WithTempMount(ctx, getMounts(snapDevice1), func(snap1MountPath string) error {
// Read test file from snapshot device and make sure it's v1
fileData, err := os.ReadFile(filepath.Join(snap1MountPath, "TEST"))
assert.NilError(t, err, "couldn't read test file from '%s' device", snapDevice1)
assert.Nil(t, err, "couldn't read test file from '%s' device", snapDevice1)
assert.Equal(t, "test file (v1)", string(fileData), "test file content is invalid on snapshot")
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
t.Run("DeactivateDevice", func(t *testing.T) {
testDeactivateThinDevice(t, pool)
@@ -157,17 +157,17 @@ func TestPoolDevice(t *testing.T) {
snapDevice := "snap2"
err := pool.CreateSnapshotDevice(ctx, thinDevice1, snapDevice, device1Size)
assert.NilError(t, err)
assert.NoError(t, err)
info, err := pool.metadata.GetDevice(ctx, snapDevice)
assert.NilError(t, err)
assert.NoError(t, err)
// Simulate a case that the device cannot be activated.
err = pool.DeactivateDevice(ctx, info.Name, false, false)
assert.NilError(t, err)
assert.NoError(t, err)
err = pool.rollbackActivate(ctx, info, err)
assert.NilError(t, err)
assert.NoError(t, err)
})
}
@@ -176,16 +176,16 @@ func TestPoolDeviceMarkFaulty(t *testing.T) {
defer cleanupStore(t, store)
err := store.AddDevice(testCtx, &DeviceInfo{Name: "1", State: Unknown})
assert.NilError(t, err)
assert.NoError(t, err)
// Note: do not use 'Activated' here because pool.ensureDeviceStates() will
// try to activate the real dm device, which will fail on a faked device.
err = store.AddDevice(testCtx, &DeviceInfo{Name: "2", State: Deactivated})
assert.NilError(t, err)
assert.NoError(t, err)
pool := &PoolDevice{metadata: store}
err = pool.ensureDeviceStates(testCtx)
assert.NilError(t, err)
assert.NoError(t, err)
called := 0
err = pool.metadata.WalkDevices(testCtx, func(info *DeviceInfo) error {
@@ -204,7 +204,7 @@ func TestPoolDeviceMarkFaulty(t *testing.T) {
return nil
})
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, 2, called)
}
@@ -212,24 +212,24 @@ func testCreateThinDevice(t *testing.T, pool *PoolDevice) {
ctx := context.Background()
err := pool.CreateThinDevice(ctx, thinDevice1, device1Size)
assert.NilError(t, err, "can't create first thin device")
assert.Nil(t, err, "can't create first thin device")
err = pool.CreateThinDevice(ctx, thinDevice1, device1Size)
assert.Assert(t, err != nil, "device pool allows duplicated device names")
assert.True(t, err != nil, "device pool allows duplicated device names")
err = pool.CreateThinDevice(ctx, thinDevice2, device2Size)
assert.NilError(t, err, "can't create second thin device")
assert.Nil(t, err, "can't create second thin device")
deviceInfo1, err := pool.metadata.GetDevice(ctx, thinDevice1)
assert.NilError(t, err)
assert.NoError(t, err)
deviceInfo2, err := pool.metadata.GetDevice(ctx, thinDevice2)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Assert(t, deviceInfo1.DeviceID != deviceInfo2.DeviceID, "assigned device ids should be different")
assert.True(t, deviceInfo1.DeviceID != deviceInfo2.DeviceID, "assigned device ids should be different")
usage, err := pool.GetUsage(thinDevice1)
assert.NilError(t, err)
assert.NoError(t, err)
assert.Equal(t, usage, int64(0))
}
@@ -242,16 +242,16 @@ func testMakeFileSystem(t *testing.T, pool *PoolDevice) {
}
output, err := exec.Command("mkfs.ext4", args...).CombinedOutput()
assert.NilError(t, err, "failed to make filesystem on '%s': %s", thinDevice1, string(output))
assert.Nil(t, err, "failed to make filesystem on '%s': %s", thinDevice1, string(output))
usage, err := pool.GetUsage(thinDevice1)
assert.NilError(t, err)
assert.Assert(t, usage > 0)
assert.NoError(t, err)
assert.True(t, usage > 0)
}
func testCreateSnapshot(t *testing.T, pool *PoolDevice) {
err := pool.CreateSnapshotDevice(context.Background(), thinDevice1, snapDevice1, device1Size)
assert.NilError(t, err, "failed to create snapshot from '%s' volume", thinDevice1)
assert.Nil(t, err, "failed to create snapshot from '%s' volume", thinDevice1)
}
func testDeactivateThinDevice(t *testing.T, pool *PoolDevice) {
@@ -261,21 +261,21 @@ func testDeactivateThinDevice(t *testing.T, pool *PoolDevice) {
}
for _, deviceName := range deviceList {
assert.Assert(t, pool.IsActivated(deviceName))
assert.True(t, pool.IsActivated(deviceName))
err := pool.DeactivateDevice(context.Background(), deviceName, false, true)
assert.NilError(t, err, "failed to remove '%s'", deviceName)
assert.Nil(t, err, "failed to remove '%s'", deviceName)
assert.Assert(t, !pool.IsActivated(deviceName))
assert.False(t, pool.IsActivated(deviceName))
}
}
func testRemoveThinDevice(t *testing.T, pool *PoolDevice) {
err := pool.RemoveDevice(testCtx, thinDevice1)
assert.NilError(t, err, "should delete thin device from pool")
assert.Nil(t, err, "should delete thin device from pool")
err = pool.RemoveDevice(testCtx, thinDevice2)
assert.NilError(t, err, "should delete thin device from pool")
assert.Nil(t, err, "should delete thin device from pool")
}
func getMounts(thinDeviceName string) []mount.Mount {
@@ -289,21 +289,21 @@ func getMounts(thinDeviceName string) []mount.Mount {
func createLoopbackDevice(t *testing.T, dir string) (string, string) {
file, err := os.CreateTemp(dir, testsPrefix)
assert.NilError(t, err)
assert.NoError(t, err)
size, err := units.RAMInBytes("128Mb")
assert.NilError(t, err)
assert.NoError(t, err)
err = file.Truncate(size)
assert.NilError(t, err)
assert.NoError(t, err)
err = file.Close()
assert.NilError(t, err)
assert.NoError(t, err)
imagePath := file.Name()
loopDevice, err := mount.AttachLoopDevice(imagePath)
assert.NilError(t, err)
assert.NoError(t, err)
return imagePath, loopDevice
}

42
snapshots/devmapper/snapshotter_test.go
View File

@@ -29,7 +29,7 @@ import (
"github.com/containerd/continuity/fs/fstest"
"github.com/hashicorp/go-multierror"
"github.com/sirupsen/logrus"
"gotest.tools/v3/assert"
"github.com/stretchr/testify/assert"
"github.com/containerd/containerd/mount"
"github.com/containerd/containerd/namespaces"
@@ -61,7 +61,7 @@ func TestSnapshotterSuite(t *testing.T) {
t.Run("DevMapperUsage", func(t *testing.T) {
snapshotter, closer, err := snapshotterFn(ctx, t.TempDir())
assert.NilError(t, err)
assert.NoError(t, err)
defer closer()
testUsage(t, snapshotter)
@@ -75,16 +75,16 @@ func testUsage(t *testing.T, snapshotter snapshots.Snapshotter) {
// Create empty base layer
_, err := snapshotter.Prepare(ctx, "prepare-1", "")
assert.NilError(t, err)
assert.NoError(t, err)
emptyLayerUsage, err := snapshotter.Usage(ctx, "prepare-1")
assert.NilError(t, err)
assert.NoError(t, err)
// Should be > 0 as just written file system also consumes blocks
assert.Assert(t, emptyLayerUsage.Size > 0)
assert.Greater(t, emptyLayerUsage.Size, int64(0))
err = snapshotter.Commit(ctx, "layer-1", "prepare-1")
assert.NilError(t, err)
assert.NoError(t, err)
// Create child layer with 1MB file
@@ -94,19 +94,19 @@ func testUsage(t *testing.T, snapshotter snapshots.Snapshotter) {
)
mounts, err := snapshotter.Prepare(ctx, "prepare-2", "layer-1")
assert.NilError(t, err)
assert.NoError(t, err)
err = mount.WithTempMount(ctx, mounts, baseApplier.Apply)
assert.NilError(t, err)
assert.NoError(t, err)
err = snapshotter.Commit(ctx, "layer-2", "prepare-2")
assert.NilError(t, err)
assert.NoError(t, err)
layer2Usage, err := snapshotter.Usage(ctx, "layer-2")
assert.NilError(t, err)
assert.NoError(t, err)
// Should be at least 1 MB + fs metadata
assert.Check(t, layer2Usage.Size >= sizeBytes,
assert.GreaterOrEqual(t, layer2Usage.Size, sizeBytes,
"%d > %d", layer2Usage.Size, sizeBytes)
}
@@ -114,26 +114,26 @@ func TestMkfsExt4(t *testing.T) {
ctx := context.Background()
// We test the default setting which is lazy init is disabled
err := mkfs(ctx, "ext4", "nodiscard,lazy_itable_init=0,lazy_journal_init=0", "")
assert.ErrorContains(t, err, `mkfs.ext4 couldn't initialize ""`)
assert.Contains(t, err.Error(), `mkfs.ext4 couldn't initialize ""`)
}
func TestMkfsExt4NonDefault(t *testing.T) {
ctx := context.Background()
// We test a non default setting where we enable lazy init for ext4
err := mkfs(ctx, "ext4", "nodiscard", "")
assert.ErrorContains(t, err, `mkfs.ext4 couldn't initialize ""`)
assert.Contains(t, err.Error(), `mkfs.ext4 couldn't initialize ""`)
}
func TestMkfsXfs(t *testing.T) {
ctx := context.Background()
err := mkfs(ctx, "xfs", "", "")
assert.ErrorContains(t, err, `mkfs.xfs couldn't initialize ""`)
assert.Contains(t, err.Error(), `mkfs.xfs couldn't initialize ""`)
}
func TestMkfsXfsNonDefault(t *testing.T) {
ctx := context.Background()
err := mkfs(ctx, "xfs", "noquota", "")
assert.ErrorContains(t, err, `mkfs.xfs couldn't initialize ""`)
assert.Contains(t, err.Error(), `mkfs.xfs couldn't initialize ""`)
}
func TestMultipleXfsMounts(t *testing.T) {
@@ -152,7 +152,7 @@ func TestMultipleXfsMounts(t *testing.T) {
FileSystemType: "xfs",
}
snapshotter, closer, err := createSnapshotter(ctx, t, config)
assert.NilError(t, err)
assert.NoError(t, err)
defer closer()
var (
@@ -162,27 +162,27 @@ func TestMultipleXfsMounts(t *testing.T) {
// Create base layer
mounts, err := snapshotter.Prepare(ctx, "prepare-1", "")
assert.NilError(t, err)
assert.NoError(t, err)
root1 := t.TempDir()
defer func() {
mount.UnmountAll(root1, 0)
}()
err = mount.All(mounts, root1)
assert.NilError(t, err)
assert.NoError(t, err)
baseApplier.Apply(root1)
snapshotter.Commit(ctx, "layer-1", "prepare-1")
// Create one child layer
mounts, err = snapshotter.Prepare(ctx, "prepare-2", "layer-1")
assert.NilError(t, err)
assert.NoError(t, err)
root2 := t.TempDir()
defer func() {
mount.UnmountAll(root2, 0)
}()
err = mount.All(mounts, root2)
assert.NilError(t, err)
assert.NoError(t, err)
}
func createSnapshotter(ctx context.Context, t *testing.T, config *Config) (snapshots.Snapshotter, func() error, error) {
@@ -191,7 +191,7 @@ func createSnapshotter(ctx context.Context, t *testing.T, config *Config) (snaps
_, loopMetaDevice := createLoopbackDevice(t, config.RootPath)
err := dmsetup.CreatePool(config.PoolName, loopDataDevice, loopMetaDevice, 64*1024/dmsetup.SectorSize)
assert.NilError(t, err, "failed to create pool %q", config.PoolName)
assert.Nil(t, err, "failed to create pool %q", config.PoolName)
snap, err := NewSnapshotter(ctx, config)
if err != nil {