opensource/podman
1
0
Fork 0
mirror of https://github.com/containers/podman.git synced 2025-07-03 09:17:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Switch all calls of assert.Nil to assert.NoError

Browse Source 
Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>
This commit is contained in:
Daniel J Walsh
2025-01-15 07:08:27 -05:00
parent 04e6488315
commit 3fb37c588d
9 changed files with 43 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/podman/common/create_test.go
View File

@ -16,7 +16,7 @@ func TestPodOptions(t *testing.T) {
podOptions := entities.PodCreateOptions{}
err := common.ContainerToPodOptions(&exampleOptions, &podOptions)
assert.Nil(t, err)
assert.NoError(t, err)
cc := reflect.ValueOf(&exampleOptions).Elem()
pc := reflect.ValueOf(&podOptions).Elem()

34
cmd/quadlet/main_test.go
View File

@ -55,9 +55,9 @@ func TestIsUnambiguousName(t *testing.T) {
func TestUnitDirs(t *testing.T) {
u, err := user.Current()
assert.Nil(t, err)
assert.NoError(t, err)
uidInt, err := strconv.Atoi(u.Uid)
assert.Nil(t, err)
assert.NoError(t, err)
if os.Getenv("_UNSHARED") != "true" {
unitDirs := getUnitDirs(false)
@ -71,7 +71,7 @@ func TestUnitDirs(t *testing.T) {
assert.Equal(t, rootfulPaths.sorted, unitDirs, "rootful unit dirs should match")
configDir, err := os.UserConfigDir()
assert.Nil(t, err)
assert.NoError(t, err)
rootlessPaths := newSearchPaths()
@ -106,13 +106,13 @@ func TestUnitDirs(t *testing.T) {
actualDir := filepath.Join(symLinkTestBaseDir, "actual")
err = os.Mkdir(actualDir, 0755)
assert.Nil(t, err)
assert.NoError(t, err)
innerDir := filepath.Join(actualDir, "inner")
err = os.Mkdir(innerDir, 0755)
assert.Nil(t, err)
assert.NoError(t, err)
symlink := filepath.Join(symLinkTestBaseDir, "symlink")
err = os.Symlink(actualDir, symlink)
assert.Nil(t, err)
assert.NoError(t, err)
t.Setenv("QUADLET_UNIT_DIRS", symlink)
unitDirs = getUnitDirs(true)
assert.Equal(t, []string{actualDir, innerDir}, unitDirs, "directory resolution should follow symlink")
@ -133,7 +133,7 @@ func TestUnitDirs(t *testing.T) {
dirName := filepath.Join(path, name)
assert.NotContains(t, dirs, dirName)
err = os.Mkdir(dirName, 0755)
assert.Nil(t, err)
assert.NoError(t, err)
dirs = append(dirs, dirName)
return dirName, dirs
}
@ -141,7 +141,7 @@ func TestUnitDirs(t *testing.T) {
linkDir := func(path, name, target string) {
linkName := filepath.Join(path, name)
err = os.Symlink(target, linkName)
assert.Nil(t, err)
assert.NoError(t, err)
}
symLinkRecursiveTestBaseDir := t.TempDir()
@ -199,39 +199,39 @@ func TestUnitDirs(t *testing.T) {
}
c.Env = append(os.Environ(), "_UNSHARED=true")
err = c.Run()
assert.Nil(t, err)
assert.NoError(t, err)
} else {
fmt.Println(os.Args)
symLinkTestBaseDir := t.TempDir()
rootF, err := os.Open("/")
assert.Nil(t, err)
assert.NoError(t, err)
defer rootF.Close()
defer func() {
err := rootF.Chdir()
assert.Nil(t, err)
assert.NoError(t, err)
err = syscall.Chroot(".")
assert.Nil(t, err)
assert.NoError(t, err)
}()
err = syscall.Chroot(symLinkTestBaseDir)
assert.Nil(t, err)
assert.NoError(t, err)
err = os.MkdirAll(quadlet.UnitDirAdmin, 0755)
assert.Nil(t, err)
assert.NoError(t, err)
err = os.RemoveAll(quadlet.UnitDirAdmin)
assert.Nil(t, err)
assert.NoError(t, err)
createDir := func(path, name string) string {
dirName := filepath.Join(path, name)
err = os.Mkdir(dirName, 0755)
assert.Nil(t, err)
assert.NoError(t, err)
return dirName
}
linkDir := func(path, name, target string) {
linkName := filepath.Join(path, name)
err = os.Symlink(target, linkName)
assert.Nil(t, err)
assert.NoError(t, err)
}
systemdDir := createDir("/", "systemd")

10
libpod/container_internal_test.go
View File

@ -33,7 +33,7 @@ func TestParseOptionIDs(t *testing.T) {
assert.NotNil(t, err)
mappings, err := parseOptionIDs(idMap, "100-200-2")
assert.Nil(t, err)
assert.NoError(t, err)
assert.NotNil(t, mappings)
assert.Equal(t, len(mappings), 1)
@ -43,7 +43,7 @@ func TestParseOptionIDs(t *testing.T) {
assert.Equal(t, mappings[0].Size, 2)
mappings, err = parseOptionIDs(idMap, "100-200-2#300-400-5")
assert.Nil(t, err)
assert.NoError(t, err)
assert.NotNil(t, mappings)
assert.Equal(t, len(mappings), 2)
@ -57,7 +57,7 @@ func TestParseOptionIDs(t *testing.T) {
assert.Equal(t, mappings[1].Size, 5)
mappings, err = parseOptionIDs(idMap, "@100-200-2#@300-400-5")
assert.Nil(t, err)
assert.NoError(t, err)
assert.NotNil(t, mappings)
assert.Equal(t, len(mappings), 2)
@ -97,7 +97,7 @@ func TestParseIDMapMountOption(t *testing.T) {
GIDMap: gidMap,
}
uids, gids, err := parseIDMapMountOption(options, "idmap")
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, len(uids), 1)
assert.Equal(t, len(gids), 1)
@ -110,7 +110,7 @@ func TestParseIDMapMountOption(t *testing.T) {
assert.Equal(t, gids[0].Size, uint32(10000))
uids, gids, err = parseIDMapMountOption(options, "idmap=uids=0-1-10#10-11-10;gids=0-3-10")
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, len(uids), 2)
assert.Equal(t, len(gids), 1)

12
pkg/domain/utils/utils_test.go
View File

@ -82,34 +82,34 @@ func TestParseSCPArgs(t *testing.T) {
var dest *entities.ScpTransferImageOptions
var err error
source, _, err = ParseImageSCPArg(args[0])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, source.Image, "alpine")
dest, _, err = ParseImageSCPArg(args[1])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, dest.Image, "")
assert.Equal(t, dest.User, "root")
args = []string{"root@localhost::alpine"}
source, _, err = ParseImageSCPArg(args[0])
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, source.User, "root")
assert.Equal(t, source.Image, "alpine")
args = []string{"charliedoern@192.168.68.126::alpine", "foobar@192.168.68.126::"}
source, _, err = ParseImageSCPArg(args[0])
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, source.Remote)
assert.Equal(t, source.Image, "alpine")
dest, _, err = ParseImageSCPArg(args[1])
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, dest.Remote)
assert.Equal(t, dest.Image, "")
args = []string{"charliedoern@192.168.68.126::alpine"}
source, _, err = ParseImageSCPArg(args[0])
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, source.Remote)
assert.Equal(t, source.Image, "alpine")
}

4
pkg/machine/config_test.go
View File

@ -13,8 +13,8 @@ import (
func TestGetSSHIdentityPath(t *testing.T) {
name := "p-test"
datadir, err := env.GetGlobalDataDir()
assert.Nil(t, err)
assert.NoError(t, err)
identityPath, err := env.GetSSHIdentityPath(name)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, identityPath, filepath.Join(datadir, name))
}

8
pkg/machine/provider/platform_test.go
View File

@ -25,14 +25,14 @@ func TestSupportedProviders(t *testing.T) {
func TestInstalledProviders(t *testing.T) {
installed, err := InstalledProviders()
assert.Nil(t, err)
assert.NoError(t, err)
switch runtime.GOOS {
case "darwin":
// TODO: need to verify if an arm64 machine reports {applehv, libkrun}
assert.Equal(t, []define.VMType{define.AppleHvVirt}, installed)
case "windows":
provider, err := Get()
assert.Nil(t, err)
assert.NoError(t, err)
assert.Contains(t, installed, provider)
case "linux":
assert.Equal(t, []define.VMType{define.QemuVirt}, installed)
@ -41,7 +41,7 @@ func TestInstalledProviders(t *testing.T) {
func TestHasPermsForProvider(t *testing.T) {
provider, err := Get()
assert.Nil(t, err)
assert.NoError(t, err)
assert.True(t, HasPermsForProvider(provider.VMType()))
}
@ -72,7 +72,7 @@ func TestBadSupportedProviders(t *testing.T) {
func TestBadInstalledProviders(t *testing.T) {
installed, err := InstalledProviders()
assert.Nil(t, err)
assert.NoError(t, err)
switch runtime.GOOS {
case "darwin":
assert.NotEqual(t, []define.VMType{define.QemuVirt}, installed)

2
pkg/specgen/generate/kube/play_test.go
View File

@ -448,7 +448,7 @@ func TestEnvVarValue(t *testing.T) {
stringNumCPUs := strconv.Itoa(runtime.NumCPU())
mi, err := meminfo.Read()
assert.Nil(t, err)
assert.NoError(t, err)
stringMemTotal := strconv.FormatInt(mi.MemTotal, 10)
tests := []struct {

10
pkg/specgenutil/specgenutil_test.go
View File

@ -59,7 +59,7 @@ func TestWinPath(t *testing.T) {
assert.NotNil(t, err, msg)
continue
}
if !assert.Nil(t, err, msg) {
if !assert.NoError(t, err, msg) {
continue
}
if test.isN {
@ -80,14 +80,14 @@ func TestWinPath(t *testing.T) {
func TestParseLinuxResourcesDeviceAccess(t *testing.T) {
d, err := parseLinuxResourcesDeviceAccess("a *:* rwm")
assert.Nil(t, err, "err is nil")
assert.NoError(t, err, "err is nil")
assert.True(t, d.Allow, "allow is true")
assert.Equal(t, d.Type, "a", "type is 'a'")
assert.Nil(t, d.Minor, "minor is nil")
assert.Nil(t, d.Major, "major is nil")
d, err = parseLinuxResourcesDeviceAccess("b 3:* rwm")
assert.Nil(t, err, "err is nil")
assert.NoError(t, err, "err is nil")
assert.True(t, d.Allow, "allow is true")
assert.Equal(t, d.Type, "b", "type is 'b'")
assert.Nil(t, d.Minor, "minor is nil")
@ -95,7 +95,7 @@ func TestParseLinuxResourcesDeviceAccess(t *testing.T) {
assert.Equal(t, *d.Major, int64(3), "major is 3")
d, err = parseLinuxResourcesDeviceAccess("a *:3 rwm")
assert.Nil(t, err, "err is nil")
assert.NoError(t, err, "err is nil")
assert.True(t, d.Allow, "allow is true")
assert.Equal(t, d.Type, "a", "type is 'a'")
assert.Nil(t, d.Major, "major is nil")
@ -103,7 +103,7 @@ func TestParseLinuxResourcesDeviceAccess(t *testing.T) {
assert.Equal(t, *d.Minor, int64(3), "minor is 3")
d, err = parseLinuxResourcesDeviceAccess("c 1:2 rwm")
assert.Nil(t, err, "err is nil")
assert.NoError(t, err, "err is nil")
assert.True(t, d.Allow, "allow is true")
assert.Equal(t, d.Type, "c", "type is 'c'")
assert.NotNil(t, d.Major, "minor is not nil")

4
pkg/util/utils_test.go
View File

@ -692,7 +692,7 @@ func TestGetRootlessKeepIDMapping(t *testing.T) {
for _, test := range tests {
options, uid, gid, err := getRootlessKeepIDMapping(test.uid, test.gid, test.uids, test.gids, test.size)
assert.Nil(t, err)
assert.NoError(t, err)
assert.Equal(t, test.expectedOptions, options)
assert.Equal(t, test.expectedUID, uid)
assert.Equal(t, test.expectedGID, gid)
@ -817,7 +817,7 @@ func TestProcessOptions(t *testing.T) {
if tt.expectErr {
assert.NotNil(t, err)
} else {
assert.Nil(t, err)
assert.NoError(t, err)
sort.Strings(opts)
sort.Strings(tt.expected)
assert.Equal(t, opts, tt.expected)