mirror of
https://github.com/containers/podman.git
synced 2025-11-04 08:56:05 +08:00
318 lines
9.7 KiB
Go
318 lines
9.7 KiB
Go
package util
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
var (
|
|
sliceData = []string{"one", "two", "three", "four"}
|
|
)
|
|
|
|
func TestStringInSlice(t *testing.T) {
|
|
// string is in the slice
|
|
assert.True(t, StringInSlice("one", sliceData))
|
|
// string is not in the slice
|
|
assert.False(t, StringInSlice("five", sliceData))
|
|
// string is not in empty slice
|
|
assert.False(t, StringInSlice("one", []string{}))
|
|
}
|
|
|
|
func TestGetImageConfigUser(t *testing.T) {
|
|
validUser, err := GetImageConfig([]string{"USER valid"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, validUser.User, "valid")
|
|
|
|
validUser2, err := GetImageConfig([]string{"USER test_user_2"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, validUser2.User, "test_user_2")
|
|
|
|
_, err = GetImageConfig([]string{"USER "})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigExpose(t *testing.T) {
|
|
validPortNoProto, err := GetImageConfig([]string{"EXPOSE 80"})
|
|
require.Nil(t, err)
|
|
_, exists := validPortNoProto.ExposedPorts["80/tcp"]
|
|
assert.True(t, exists)
|
|
|
|
validPortTCP, err := GetImageConfig([]string{"EXPOSE 80/tcp"})
|
|
require.Nil(t, err)
|
|
_, exists = validPortTCP.ExposedPorts["80/tcp"]
|
|
assert.True(t, exists)
|
|
|
|
validPortUDP, err := GetImageConfig([]string{"EXPOSE 80/udp"})
|
|
require.Nil(t, err)
|
|
_, exists = validPortUDP.ExposedPorts["80/udp"]
|
|
assert.True(t, exists)
|
|
|
|
_, err = GetImageConfig([]string{"EXPOSE 99999"})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"EXPOSE 80/notaproto"})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"EXPOSE "})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"EXPOSE thisisnotanumber"})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigEnv(t *testing.T) {
|
|
validEnvNoValue, err := GetImageConfig([]string{"ENV key"})
|
|
require.Nil(t, err)
|
|
assert.True(t, StringInSlice("key=", validEnvNoValue.Env))
|
|
|
|
validEnvBareEquals, err := GetImageConfig([]string{"ENV key="})
|
|
require.Nil(t, err)
|
|
assert.True(t, StringInSlice("key=", validEnvBareEquals.Env))
|
|
|
|
validEnvKeyValue, err := GetImageConfig([]string{"ENV key=value"})
|
|
require.Nil(t, err)
|
|
assert.True(t, StringInSlice("key=value", validEnvKeyValue.Env))
|
|
|
|
validEnvKeyMultiEntryValue, err := GetImageConfig([]string{`ENV key="value1 value2"`})
|
|
require.Nil(t, err)
|
|
assert.True(t, StringInSlice("key=value1 value2", validEnvKeyMultiEntryValue.Env))
|
|
|
|
_, err = GetImageConfig([]string{"ENV "})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigEntrypoint(t *testing.T) {
|
|
binShEntrypoint, err := GetImageConfig([]string{"ENTRYPOINT /bin/bash"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 3, len(binShEntrypoint.Entrypoint))
|
|
assert.Equal(t, binShEntrypoint.Entrypoint[0], "/bin/sh")
|
|
assert.Equal(t, binShEntrypoint.Entrypoint[1], "-c")
|
|
assert.Equal(t, binShEntrypoint.Entrypoint[2], "/bin/bash")
|
|
|
|
entrypointWithSpaces, err := GetImageConfig([]string{"ENTRYPOINT ls -al"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 3, len(entrypointWithSpaces.Entrypoint))
|
|
assert.Equal(t, entrypointWithSpaces.Entrypoint[0], "/bin/sh")
|
|
assert.Equal(t, entrypointWithSpaces.Entrypoint[1], "-c")
|
|
assert.Equal(t, entrypointWithSpaces.Entrypoint[2], "ls -al")
|
|
|
|
jsonArrayEntrypoint, err := GetImageConfig([]string{`ENTRYPOINT ["ls", "-al"]`})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 2, len(jsonArrayEntrypoint.Entrypoint))
|
|
assert.Equal(t, jsonArrayEntrypoint.Entrypoint[0], "ls")
|
|
assert.Equal(t, jsonArrayEntrypoint.Entrypoint[1], "-al")
|
|
|
|
emptyEntrypoint, err := GetImageConfig([]string{"ENTRYPOINT "})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, 0, len(emptyEntrypoint.Entrypoint))
|
|
|
|
emptyEntrypointArray, err := GetImageConfig([]string{"ENTRYPOINT []"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, 0, len(emptyEntrypointArray.Entrypoint))
|
|
}
|
|
|
|
func TestGetImageConfigCmd(t *testing.T) {
|
|
binShCmd, err := GetImageConfig([]string{"CMD /bin/bash"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 3, len(binShCmd.Cmd))
|
|
assert.Equal(t, binShCmd.Cmd[0], "/bin/sh")
|
|
assert.Equal(t, binShCmd.Cmd[1], "-c")
|
|
assert.Equal(t, binShCmd.Cmd[2], "/bin/bash")
|
|
|
|
cmdWithSpaces, err := GetImageConfig([]string{"CMD ls -al"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 3, len(cmdWithSpaces.Cmd))
|
|
assert.Equal(t, cmdWithSpaces.Cmd[0], "/bin/sh")
|
|
assert.Equal(t, cmdWithSpaces.Cmd[1], "-c")
|
|
assert.Equal(t, cmdWithSpaces.Cmd[2], "ls -al")
|
|
|
|
jsonArrayCmd, err := GetImageConfig([]string{`CMD ["ls", "-al"]`})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 2, len(jsonArrayCmd.Cmd))
|
|
assert.Equal(t, jsonArrayCmd.Cmd[0], "ls")
|
|
assert.Equal(t, jsonArrayCmd.Cmd[1], "-al")
|
|
|
|
emptyCmd, err := GetImageConfig([]string{"CMD "})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 2, len(emptyCmd.Cmd))
|
|
assert.Equal(t, emptyCmd.Cmd[0], "/bin/sh")
|
|
assert.Equal(t, emptyCmd.Cmd[1], "-c")
|
|
|
|
blankCmd, err := GetImageConfig([]string{"CMD []"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, 0, len(blankCmd.Cmd))
|
|
}
|
|
|
|
func TestGetImageConfigVolume(t *testing.T) {
|
|
oneLenJSONArrayVol, err := GetImageConfig([]string{`VOLUME ["/test1"]`})
|
|
require.Nil(t, err)
|
|
_, exists := oneLenJSONArrayVol.Volumes["/test1"]
|
|
assert.True(t, exists)
|
|
assert.Equal(t, 1, len(oneLenJSONArrayVol.Volumes))
|
|
|
|
twoLenJSONArrayVol, err := GetImageConfig([]string{`VOLUME ["/test1", "/test2"]`})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, 2, len(twoLenJSONArrayVol.Volumes))
|
|
_, exists = twoLenJSONArrayVol.Volumes["/test1"]
|
|
assert.True(t, exists)
|
|
_, exists = twoLenJSONArrayVol.Volumes["/test2"]
|
|
assert.True(t, exists)
|
|
|
|
oneLenVol, err := GetImageConfig([]string{"VOLUME /test1"})
|
|
require.Nil(t, err)
|
|
_, exists = oneLenVol.Volumes["/test1"]
|
|
assert.True(t, exists)
|
|
assert.Equal(t, 1, len(oneLenVol.Volumes))
|
|
|
|
twoLenVol, err := GetImageConfig([]string{"VOLUME /test1 /test2"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, 2, len(twoLenVol.Volumes))
|
|
_, exists = twoLenVol.Volumes["/test1"]
|
|
assert.True(t, exists)
|
|
_, exists = twoLenVol.Volumes["/test2"]
|
|
assert.True(t, exists)
|
|
|
|
_, err = GetImageConfig([]string{"VOLUME []"})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"VOLUME "})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{`VOLUME [""]`})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigWorkdir(t *testing.T) {
|
|
singleWorkdir, err := GetImageConfig([]string{"WORKDIR /testdir"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, singleWorkdir.WorkingDir, "/testdir")
|
|
|
|
twoWorkdirs, err := GetImageConfig([]string{"WORKDIR /testdir", "WORKDIR a"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, twoWorkdirs.WorkingDir, "/testdir/a")
|
|
|
|
_, err = GetImageConfig([]string{"WORKDIR "})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigLabel(t *testing.T) {
|
|
labelNoQuotes, err := GetImageConfig([]string{"LABEL key1=value1"})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, labelNoQuotes.Labels["key1"], "value1")
|
|
|
|
labelWithQuotes, err := GetImageConfig([]string{`LABEL "key 1"="value 2"`})
|
|
require.Nil(t, err)
|
|
assert.Equal(t, labelWithQuotes.Labels["key 1"], "value 2")
|
|
|
|
labelNoValue, err := GetImageConfig([]string{"LABEL key="})
|
|
require.Nil(t, err)
|
|
contents, exists := labelNoValue.Labels["key"]
|
|
assert.True(t, exists)
|
|
assert.Equal(t, contents, "")
|
|
|
|
_, err = GetImageConfig([]string{"LABEL key"})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"LABEL "})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigOnBuild(t *testing.T) {
|
|
onBuildOne, err := GetImageConfig([]string{"ONBUILD ADD /testdir1"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 1, len(onBuildOne.OnBuild))
|
|
assert.Equal(t, onBuildOne.OnBuild[0], "ADD /testdir1")
|
|
|
|
onBuildTwo, err := GetImageConfig([]string{"ONBUILD ADD /testdir1", "ONBUILD ADD /testdir2"})
|
|
require.Nil(t, err)
|
|
require.Equal(t, 2, len(onBuildTwo.OnBuild))
|
|
assert.Equal(t, onBuildTwo.OnBuild[0], "ADD /testdir1")
|
|
assert.Equal(t, onBuildTwo.OnBuild[1], "ADD /testdir2")
|
|
|
|
_, err = GetImageConfig([]string{"ONBUILD "})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestGetImageConfigMisc(t *testing.T) {
|
|
_, err := GetImageConfig([]string{""})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"USER"})
|
|
assert.NotNil(t, err)
|
|
|
|
_, err = GetImageConfig([]string{"BADINST testvalue"})
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestValidateSysctls(t *testing.T) {
|
|
strSlice := []string{"net.core.test1=4", "kernel.msgmax=2"}
|
|
result, _ := ValidateSysctls(strSlice)
|
|
assert.Equal(t, result["net.core.test1"], "4")
|
|
}
|
|
|
|
func TestValidateSysctlBadSysctl(t *testing.T) {
|
|
strSlice := []string{"BLAU=BLUE", "GELB^YELLOW"}
|
|
_, err := ValidateSysctls(strSlice)
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestValidateSysctlBadSysctlWithExtraSpaces(t *testing.T) {
|
|
expectedError := "'%s' is invalid, extra spaces found"
|
|
|
|
// should fail fast on first sysctl
|
|
strSlice1 := []string{
|
|
"net.ipv4.ping_group_range = 0 0",
|
|
"net.ipv4.ping_group_range=0 0 ",
|
|
}
|
|
_, err := ValidateSysctls(strSlice1)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, err.Error(), fmt.Sprintf(expectedError, strSlice1[0]))
|
|
|
|
// should fail on second sysctl
|
|
strSlice2 := []string{
|
|
"net.ipv4.ping_group_range=0 0",
|
|
"net.ipv4.ping_group_range=0 0 ",
|
|
}
|
|
_, err = ValidateSysctls(strSlice2)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, err.Error(), fmt.Sprintf(expectedError, strSlice2[1]))
|
|
}
|
|
|
|
func TestCoresToPeriodAndQuota(t *testing.T) {
|
|
cores := 1.0
|
|
expectedPeriod := DefaultCPUPeriod
|
|
expectedQuota := int64(DefaultCPUPeriod)
|
|
|
|
actualPeriod, actualQuota := CoresToPeriodAndQuota(cores)
|
|
assert.Equal(t, actualPeriod, expectedPeriod, "Period does not match")
|
|
assert.Equal(t, actualQuota, expectedQuota, "Quota does not match")
|
|
}
|
|
|
|
func TestPeriodAndQuotaToCores(t *testing.T) {
|
|
var (
|
|
period uint64 = 100000
|
|
quota int64 = 50000
|
|
expectedCores = 0.5
|
|
)
|
|
|
|
assert.Equal(t, PeriodAndQuotaToCores(period, quota), expectedCores)
|
|
}
|
|
|
|
func TestParseInputTime(t *testing.T) {
|
|
tm, err := ParseInputTime("1.5", true)
|
|
if err != nil {
|
|
t.Errorf("expected error to be nil but was: %v", err)
|
|
}
|
|
|
|
expected, err := time.ParseInLocation(time.RFC3339Nano, "1970-01-01T00:00:01.500000000Z", time.UTC)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
assert.Equal(t, expected, tm)
|
|
}
|