github.com/containers/libpod@v1.9.4-0.20220419124438-4284fd425507/pkg/util/utils_test.go (about)

     1  package util
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"github.com/stretchr/testify/require"
     8  )
     9  
    10  var (
    11  	sliceData = []string{"one", "two", "three", "four"}
    12  )
    13  
    14  func TestStringInSlice(t *testing.T) {
    15  	// string is in the slice
    16  	assert.True(t, StringInSlice("one", sliceData))
    17  	// string is not in the slice
    18  	assert.False(t, StringInSlice("five", sliceData))
    19  	// string is not in empty slice
    20  	assert.False(t, StringInSlice("one", []string{}))
    21  }
    22  
    23  func TestGetImageConfigUser(t *testing.T) {
    24  	validUser, err := GetImageConfig([]string{"USER valid"})
    25  	require.Nil(t, err)
    26  	assert.Equal(t, validUser.User, "valid")
    27  
    28  	validUser2, err := GetImageConfig([]string{"USER test_user_2"})
    29  	require.Nil(t, err)
    30  	assert.Equal(t, validUser2.User, "test_user_2")
    31  
    32  	_, err = GetImageConfig([]string{"USER "})
    33  	assert.NotNil(t, err)
    34  }
    35  
    36  func TestGetImageConfigExpose(t *testing.T) {
    37  	validPortNoProto, err := GetImageConfig([]string{"EXPOSE 80"})
    38  	require.Nil(t, err)
    39  	_, exists := validPortNoProto.ExposedPorts["80/tcp"]
    40  	assert.True(t, exists)
    41  
    42  	validPortTCP, err := GetImageConfig([]string{"EXPOSE 80/tcp"})
    43  	require.Nil(t, err)
    44  	_, exists = validPortTCP.ExposedPorts["80/tcp"]
    45  	assert.True(t, exists)
    46  
    47  	validPortUDP, err := GetImageConfig([]string{"EXPOSE 80/udp"})
    48  	require.Nil(t, err)
    49  	_, exists = validPortUDP.ExposedPorts["80/udp"]
    50  	assert.True(t, exists)
    51  
    52  	_, err = GetImageConfig([]string{"EXPOSE 99999"})
    53  	assert.NotNil(t, err)
    54  
    55  	_, err = GetImageConfig([]string{"EXPOSE 80/notaproto"})
    56  	assert.NotNil(t, err)
    57  
    58  	_, err = GetImageConfig([]string{"EXPOSE "})
    59  	assert.NotNil(t, err)
    60  
    61  	_, err = GetImageConfig([]string{"EXPOSE thisisnotanumber"})
    62  	assert.NotNil(t, err)
    63  }
    64  
    65  func TestGetImageConfigEnv(t *testing.T) {
    66  	validEnvNoValue, err := GetImageConfig([]string{"ENV key"})
    67  	require.Nil(t, err)
    68  	assert.True(t, StringInSlice("key=", validEnvNoValue.Env))
    69  
    70  	validEnvBareEquals, err := GetImageConfig([]string{"ENV key="})
    71  	require.Nil(t, err)
    72  	assert.True(t, StringInSlice("key=", validEnvBareEquals.Env))
    73  
    74  	validEnvKeyValue, err := GetImageConfig([]string{"ENV key=value"})
    75  	require.Nil(t, err)
    76  	assert.True(t, StringInSlice("key=value", validEnvKeyValue.Env))
    77  
    78  	validEnvKeyMultiEntryValue, err := GetImageConfig([]string{`ENV key="value1 value2"`})
    79  	require.Nil(t, err)
    80  	assert.True(t, StringInSlice("key=value1 value2", validEnvKeyMultiEntryValue.Env))
    81  
    82  	_, err = GetImageConfig([]string{"ENV "})
    83  	assert.NotNil(t, err)
    84  }
    85  
    86  func TestGetImageConfigEntrypoint(t *testing.T) {
    87  	binShEntrypoint, err := GetImageConfig([]string{"ENTRYPOINT /bin/bash"})
    88  	require.Nil(t, err)
    89  	require.Equal(t, 3, len(binShEntrypoint.Entrypoint))
    90  	assert.Equal(t, binShEntrypoint.Entrypoint[0], "/bin/sh")
    91  	assert.Equal(t, binShEntrypoint.Entrypoint[1], "-c")
    92  	assert.Equal(t, binShEntrypoint.Entrypoint[2], "/bin/bash")
    93  
    94  	entrypointWithSpaces, err := GetImageConfig([]string{"ENTRYPOINT ls -al"})
    95  	require.Nil(t, err)
    96  	require.Equal(t, 3, len(entrypointWithSpaces.Entrypoint))
    97  	assert.Equal(t, entrypointWithSpaces.Entrypoint[0], "/bin/sh")
    98  	assert.Equal(t, entrypointWithSpaces.Entrypoint[1], "-c")
    99  	assert.Equal(t, entrypointWithSpaces.Entrypoint[2], "ls -al")
   100  
   101  	jsonArrayEntrypoint, err := GetImageConfig([]string{`ENTRYPOINT ["ls", "-al"]`})
   102  	require.Nil(t, err)
   103  	require.Equal(t, 2, len(jsonArrayEntrypoint.Entrypoint))
   104  	assert.Equal(t, jsonArrayEntrypoint.Entrypoint[0], "ls")
   105  	assert.Equal(t, jsonArrayEntrypoint.Entrypoint[1], "-al")
   106  
   107  	emptyEntrypoint, err := GetImageConfig([]string{"ENTRYPOINT "})
   108  	require.Nil(t, err)
   109  	assert.Equal(t, 0, len(emptyEntrypoint.Entrypoint))
   110  
   111  	emptyEntrypointArray, err := GetImageConfig([]string{"ENTRYPOINT []"})
   112  	require.Nil(t, err)
   113  	assert.Equal(t, 0, len(emptyEntrypointArray.Entrypoint))
   114  }
   115  
   116  func TestGetImageConfigCmd(t *testing.T) {
   117  	binShCmd, err := GetImageConfig([]string{"CMD /bin/bash"})
   118  	require.Nil(t, err)
   119  	require.Equal(t, 3, len(binShCmd.Cmd))
   120  	assert.Equal(t, binShCmd.Cmd[0], "/bin/sh")
   121  	assert.Equal(t, binShCmd.Cmd[1], "-c")
   122  	assert.Equal(t, binShCmd.Cmd[2], "/bin/bash")
   123  
   124  	cmdWithSpaces, err := GetImageConfig([]string{"CMD ls -al"})
   125  	require.Nil(t, err)
   126  	require.Equal(t, 3, len(cmdWithSpaces.Cmd))
   127  	assert.Equal(t, cmdWithSpaces.Cmd[0], "/bin/sh")
   128  	assert.Equal(t, cmdWithSpaces.Cmd[1], "-c")
   129  	assert.Equal(t, cmdWithSpaces.Cmd[2], "ls -al")
   130  
   131  	jsonArrayCmd, err := GetImageConfig([]string{`CMD ["ls", "-al"]`})
   132  	require.Nil(t, err)
   133  	require.Equal(t, 2, len(jsonArrayCmd.Cmd))
   134  	assert.Equal(t, jsonArrayCmd.Cmd[0], "ls")
   135  	assert.Equal(t, jsonArrayCmd.Cmd[1], "-al")
   136  
   137  	emptyCmd, err := GetImageConfig([]string{"CMD "})
   138  	require.Nil(t, err)
   139  	require.Equal(t, 2, len(emptyCmd.Cmd))
   140  	assert.Equal(t, emptyCmd.Cmd[0], "/bin/sh")
   141  	assert.Equal(t, emptyCmd.Cmd[1], "-c")
   142  
   143  	blankCmd, err := GetImageConfig([]string{"CMD []"})
   144  	require.Nil(t, err)
   145  	assert.Equal(t, 0, len(blankCmd.Cmd))
   146  }
   147  
   148  func TestGetImageConfigVolume(t *testing.T) {
   149  	oneLenJSONArrayVol, err := GetImageConfig([]string{`VOLUME ["/test1"]`})
   150  	require.Nil(t, err)
   151  	_, exists := oneLenJSONArrayVol.Volumes["/test1"]
   152  	assert.True(t, exists)
   153  	assert.Equal(t, 1, len(oneLenJSONArrayVol.Volumes))
   154  
   155  	twoLenJSONArrayVol, err := GetImageConfig([]string{`VOLUME ["/test1", "/test2"]`})
   156  	require.Nil(t, err)
   157  	assert.Equal(t, 2, len(twoLenJSONArrayVol.Volumes))
   158  	_, exists = twoLenJSONArrayVol.Volumes["/test1"]
   159  	assert.True(t, exists)
   160  	_, exists = twoLenJSONArrayVol.Volumes["/test2"]
   161  	assert.True(t, exists)
   162  
   163  	oneLenVol, err := GetImageConfig([]string{"VOLUME /test1"})
   164  	require.Nil(t, err)
   165  	_, exists = oneLenVol.Volumes["/test1"]
   166  	assert.True(t, exists)
   167  	assert.Equal(t, 1, len(oneLenVol.Volumes))
   168  
   169  	twoLenVol, err := GetImageConfig([]string{"VOLUME /test1 /test2"})
   170  	require.Nil(t, err)
   171  	assert.Equal(t, 2, len(twoLenVol.Volumes))
   172  	_, exists = twoLenVol.Volumes["/test1"]
   173  	assert.True(t, exists)
   174  	_, exists = twoLenVol.Volumes["/test2"]
   175  	assert.True(t, exists)
   176  
   177  	_, err = GetImageConfig([]string{"VOLUME []"})
   178  	assert.NotNil(t, err)
   179  
   180  	_, err = GetImageConfig([]string{"VOLUME "})
   181  	assert.NotNil(t, err)
   182  
   183  	_, err = GetImageConfig([]string{`VOLUME [""]`})
   184  	assert.NotNil(t, err)
   185  }
   186  
   187  func TestGetImageConfigWorkdir(t *testing.T) {
   188  	singleWorkdir, err := GetImageConfig([]string{"WORKDIR /testdir"})
   189  	require.Nil(t, err)
   190  	assert.Equal(t, singleWorkdir.WorkingDir, "/testdir")
   191  
   192  	twoWorkdirs, err := GetImageConfig([]string{"WORKDIR /testdir", "WORKDIR a"})
   193  	require.Nil(t, err)
   194  	assert.Equal(t, twoWorkdirs.WorkingDir, "/testdir/a")
   195  
   196  	_, err = GetImageConfig([]string{"WORKDIR "})
   197  	assert.NotNil(t, err)
   198  }
   199  
   200  func TestGetImageConfigLabel(t *testing.T) {
   201  	labelNoQuotes, err := GetImageConfig([]string{"LABEL key1=value1"})
   202  	require.Nil(t, err)
   203  	assert.Equal(t, labelNoQuotes.Labels["key1"], "value1")
   204  
   205  	labelWithQuotes, err := GetImageConfig([]string{`LABEL "key 1"="value 2"`})
   206  	require.Nil(t, err)
   207  	assert.Equal(t, labelWithQuotes.Labels["key 1"], "value 2")
   208  
   209  	labelNoValue, err := GetImageConfig([]string{"LABEL key="})
   210  	require.Nil(t, err)
   211  	contents, exists := labelNoValue.Labels["key"]
   212  	assert.True(t, exists)
   213  	assert.Equal(t, contents, "")
   214  
   215  	_, err = GetImageConfig([]string{"LABEL key"})
   216  	assert.NotNil(t, err)
   217  
   218  	_, err = GetImageConfig([]string{"LABEL "})
   219  	assert.NotNil(t, err)
   220  }
   221  
   222  func TestGetImageConfigOnBuild(t *testing.T) {
   223  	onBuildOne, err := GetImageConfig([]string{"ONBUILD ADD /testdir1"})
   224  	require.Nil(t, err)
   225  	require.Equal(t, 1, len(onBuildOne.OnBuild))
   226  	assert.Equal(t, onBuildOne.OnBuild[0], "ADD /testdir1")
   227  
   228  	onBuildTwo, err := GetImageConfig([]string{"ONBUILD ADD /testdir1", "ONBUILD ADD /testdir2"})
   229  	require.Nil(t, err)
   230  	require.Equal(t, 2, len(onBuildTwo.OnBuild))
   231  	assert.Equal(t, onBuildTwo.OnBuild[0], "ADD /testdir1")
   232  	assert.Equal(t, onBuildTwo.OnBuild[1], "ADD /testdir2")
   233  
   234  	_, err = GetImageConfig([]string{"ONBUILD "})
   235  	assert.NotNil(t, err)
   236  }
   237  
   238  func TestGetImageConfigMisc(t *testing.T) {
   239  	_, err := GetImageConfig([]string{""})
   240  	assert.NotNil(t, err)
   241  
   242  	_, err = GetImageConfig([]string{"USER"})
   243  	assert.NotNil(t, err)
   244  
   245  	_, err = GetImageConfig([]string{"BADINST testvalue"})
   246  	assert.NotNil(t, err)
   247  }
   248  
   249  func TestValidateSysctls(t *testing.T) {
   250  	strSlice := []string{"net.core.test1=4", "kernel.msgmax=2"}
   251  	result, _ := ValidateSysctls(strSlice)
   252  	assert.Equal(t, result["net.core.test1"], "4")
   253  }
   254  
   255  func TestValidateSysctlBadSysctl(t *testing.T) {
   256  	strSlice := []string{"BLAU=BLUE", "GELB^YELLOW"}
   257  	_, err := ValidateSysctls(strSlice)
   258  	assert.Error(t, err)
   259  }