dispatchers_test.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468
  1. package dockerfile
  2. import (
  3. "bytes"
  4. "context"
  5. "runtime"
  6. "testing"
  7. "github.com/docker/docker/api/types"
  8. "github.com/docker/docker/api/types/backend"
  9. "github.com/docker/docker/api/types/container"
  10. "github.com/docker/docker/api/types/strslice"
  11. "github.com/docker/docker/builder"
  12. "github.com/docker/docker/builder/dockerfile/instructions"
  13. "github.com/docker/docker/pkg/system"
  14. "github.com/docker/go-connections/nat"
  15. "github.com/stretchr/testify/assert"
  16. "github.com/stretchr/testify/require"
  17. )
  18. func newBuilderWithMockBackend() *Builder {
  19. mockBackend := &MockBackend{}
  20. ctx := context.Background()
  21. b := &Builder{
  22. options: &types.ImageBuildOptions{Platform: runtime.GOOS},
  23. docker: mockBackend,
  24. Stdout: new(bytes.Buffer),
  25. clientCtx: ctx,
  26. disableCommit: true,
  27. imageSources: newImageSources(ctx, builderOptions{
  28. Options: &types.ImageBuildOptions{Platform: runtime.GOOS},
  29. Backend: mockBackend,
  30. }),
  31. imageProber: newImageProber(mockBackend, nil, runtime.GOOS, false),
  32. containerManager: newContainerManager(mockBackend),
  33. }
  34. return b
  35. }
  36. func TestEnv2Variables(t *testing.T) {
  37. b := newBuilderWithMockBackend()
  38. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  39. envCommand := &instructions.EnvCommand{
  40. Env: instructions.KeyValuePairs{
  41. instructions.KeyValuePair{Key: "var1", Value: "val1"},
  42. instructions.KeyValuePair{Key: "var2", Value: "val2"},
  43. },
  44. }
  45. err := dispatch(sb, envCommand)
  46. require.NoError(t, err)
  47. expected := []string{
  48. "var1=val1",
  49. "var2=val2",
  50. }
  51. assert.Equal(t, expected, sb.state.runConfig.Env)
  52. }
  53. func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {
  54. b := newBuilderWithMockBackend()
  55. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  56. sb.state.runConfig.Env = []string{"var1=old", "var2=fromenv"}
  57. envCommand := &instructions.EnvCommand{
  58. Env: instructions.KeyValuePairs{
  59. instructions.KeyValuePair{Key: "var1", Value: "val1"},
  60. },
  61. }
  62. err := dispatch(sb, envCommand)
  63. require.NoError(t, err)
  64. expected := []string{
  65. "var1=val1",
  66. "var2=fromenv",
  67. }
  68. assert.Equal(t, expected, sb.state.runConfig.Env)
  69. }
  70. func TestMaintainer(t *testing.T) {
  71. maintainerEntry := "Some Maintainer <maintainer@example.com>"
  72. b := newBuilderWithMockBackend()
  73. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  74. cmd := &instructions.MaintainerCommand{Maintainer: maintainerEntry}
  75. err := dispatch(sb, cmd)
  76. require.NoError(t, err)
  77. assert.Equal(t, maintainerEntry, sb.state.maintainer)
  78. }
  79. func TestLabel(t *testing.T) {
  80. labelName := "label"
  81. labelValue := "value"
  82. b := newBuilderWithMockBackend()
  83. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  84. cmd := &instructions.LabelCommand{
  85. Labels: instructions.KeyValuePairs{
  86. instructions.KeyValuePair{Key: labelName, Value: labelValue},
  87. },
  88. }
  89. err := dispatch(sb, cmd)
  90. require.NoError(t, err)
  91. require.Contains(t, sb.state.runConfig.Labels, labelName)
  92. assert.Equal(t, sb.state.runConfig.Labels[labelName], labelValue)
  93. }
  94. func TestFromScratch(t *testing.T) {
  95. b := newBuilderWithMockBackend()
  96. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  97. cmd := &instructions.Stage{
  98. BaseName: "scratch",
  99. }
  100. err := initializeStage(sb, cmd)
  101. if runtime.GOOS == "windows" && !system.LCOWSupported() {
  102. assert.EqualError(t, err, "Windows does not support FROM scratch")
  103. return
  104. }
  105. require.NoError(t, err)
  106. assert.True(t, sb.state.hasFromImage())
  107. assert.Equal(t, "", sb.state.imageID)
  108. expected := "PATH=" + system.DefaultPathEnv(runtime.GOOS)
  109. assert.Equal(t, []string{expected}, sb.state.runConfig.Env)
  110. }
  111. func TestFromWithArg(t *testing.T) {
  112. tag, expected := ":sometag", "expectedthisid"
  113. getImage := func(name string) (builder.Image, builder.ReleaseableLayer, error) {
  114. assert.Equal(t, "alpine"+tag, name)
  115. return &mockImage{id: "expectedthisid"}, nil, nil
  116. }
  117. b := newBuilderWithMockBackend()
  118. b.docker.(*MockBackend).getImageFunc = getImage
  119. args := newBuildArgs(make(map[string]*string))
  120. val := "sometag"
  121. metaArg := instructions.ArgCommand{
  122. Key: "THETAG",
  123. Value: &val,
  124. }
  125. cmd := &instructions.Stage{
  126. BaseName: "alpine:${THETAG}",
  127. }
  128. err := processMetaArg(metaArg, NewShellLex('\\'), args)
  129. sb := newDispatchRequest(b, '\\', nil, args, newStagesBuildResults())
  130. require.NoError(t, err)
  131. err = initializeStage(sb, cmd)
  132. require.NoError(t, err)
  133. assert.Equal(t, expected, sb.state.imageID)
  134. assert.Equal(t, expected, sb.state.baseImage.ImageID())
  135. assert.Len(t, sb.state.buildArgs.GetAllAllowed(), 0)
  136. assert.Len(t, sb.state.buildArgs.GetAllMeta(), 1)
  137. }
  138. func TestFromWithUndefinedArg(t *testing.T) {
  139. tag, expected := "sometag", "expectedthisid"
  140. getImage := func(name string) (builder.Image, builder.ReleaseableLayer, error) {
  141. assert.Equal(t, "alpine", name)
  142. return &mockImage{id: "expectedthisid"}, nil, nil
  143. }
  144. b := newBuilderWithMockBackend()
  145. b.docker.(*MockBackend).getImageFunc = getImage
  146. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  147. b.options.BuildArgs = map[string]*string{"THETAG": &tag}
  148. cmd := &instructions.Stage{
  149. BaseName: "alpine${THETAG}",
  150. }
  151. err := initializeStage(sb, cmd)
  152. require.NoError(t, err)
  153. assert.Equal(t, expected, sb.state.imageID)
  154. }
  155. func TestFromMultiStageWithNamedStage(t *testing.T) {
  156. b := newBuilderWithMockBackend()
  157. firstFrom := &instructions.Stage{BaseName: "someimg", Name: "base"}
  158. secondFrom := &instructions.Stage{BaseName: "base"}
  159. previousResults := newStagesBuildResults()
  160. firstSB := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), previousResults)
  161. secondSB := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), previousResults)
  162. err := initializeStage(firstSB, firstFrom)
  163. require.NoError(t, err)
  164. assert.True(t, firstSB.state.hasFromImage())
  165. previousResults.indexed["base"] = firstSB.state.runConfig
  166. previousResults.flat = append(previousResults.flat, firstSB.state.runConfig)
  167. err = initializeStage(secondSB, secondFrom)
  168. require.NoError(t, err)
  169. assert.True(t, secondSB.state.hasFromImage())
  170. }
  171. func TestOnbuild(t *testing.T) {
  172. b := newBuilderWithMockBackend()
  173. sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  174. cmd := &instructions.OnbuildCommand{
  175. Expression: "ADD . /app/src",
  176. }
  177. err := dispatch(sb, cmd)
  178. require.NoError(t, err)
  179. assert.Equal(t, "ADD . /app/src", sb.state.runConfig.OnBuild[0])
  180. }
  181. func TestWorkdir(t *testing.T) {
  182. b := newBuilderWithMockBackend()
  183. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  184. workingDir := "/app"
  185. if runtime.GOOS == "windows" {
  186. workingDir = "C:\\app"
  187. }
  188. cmd := &instructions.WorkdirCommand{
  189. Path: workingDir,
  190. }
  191. err := dispatch(sb, cmd)
  192. require.NoError(t, err)
  193. assert.Equal(t, workingDir, sb.state.runConfig.WorkingDir)
  194. }
  195. func TestCmd(t *testing.T) {
  196. b := newBuilderWithMockBackend()
  197. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  198. command := "./executable"
  199. cmd := &instructions.CmdCommand{
  200. ShellDependantCmdLine: instructions.ShellDependantCmdLine{
  201. CmdLine: strslice.StrSlice{command},
  202. PrependShell: true,
  203. },
  204. }
  205. err := dispatch(sb, cmd)
  206. require.NoError(t, err)
  207. var expectedCommand strslice.StrSlice
  208. if runtime.GOOS == "windows" {
  209. expectedCommand = strslice.StrSlice(append([]string{"cmd"}, "/S", "/C", command))
  210. } else {
  211. expectedCommand = strslice.StrSlice(append([]string{"/bin/sh"}, "-c", command))
  212. }
  213. assert.Equal(t, expectedCommand, sb.state.runConfig.Cmd)
  214. assert.True(t, sb.state.cmdSet)
  215. }
  216. func TestHealthcheckNone(t *testing.T) {
  217. b := newBuilderWithMockBackend()
  218. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  219. cmd := &instructions.HealthCheckCommand{
  220. Health: &container.HealthConfig{
  221. Test: []string{"NONE"},
  222. },
  223. }
  224. err := dispatch(sb, cmd)
  225. require.NoError(t, err)
  226. require.NotNil(t, sb.state.runConfig.Healthcheck)
  227. assert.Equal(t, []string{"NONE"}, sb.state.runConfig.Healthcheck.Test)
  228. }
  229. func TestHealthcheckCmd(t *testing.T) {
  230. b := newBuilderWithMockBackend()
  231. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  232. expectedTest := []string{"CMD-SHELL", "curl -f http://localhost/ || exit 1"}
  233. cmd := &instructions.HealthCheckCommand{
  234. Health: &container.HealthConfig{
  235. Test: expectedTest,
  236. },
  237. }
  238. err := dispatch(sb, cmd)
  239. require.NoError(t, err)
  240. require.NotNil(t, sb.state.runConfig.Healthcheck)
  241. assert.Equal(t, expectedTest, sb.state.runConfig.Healthcheck.Test)
  242. }
  243. func TestEntrypoint(t *testing.T) {
  244. b := newBuilderWithMockBackend()
  245. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  246. entrypointCmd := "/usr/sbin/nginx"
  247. cmd := &instructions.EntrypointCommand{
  248. ShellDependantCmdLine: instructions.ShellDependantCmdLine{
  249. CmdLine: strslice.StrSlice{entrypointCmd},
  250. PrependShell: true,
  251. },
  252. }
  253. err := dispatch(sb, cmd)
  254. require.NoError(t, err)
  255. require.NotNil(t, sb.state.runConfig.Entrypoint)
  256. var expectedEntrypoint strslice.StrSlice
  257. if runtime.GOOS == "windows" {
  258. expectedEntrypoint = strslice.StrSlice(append([]string{"cmd"}, "/S", "/C", entrypointCmd))
  259. } else {
  260. expectedEntrypoint = strslice.StrSlice(append([]string{"/bin/sh"}, "-c", entrypointCmd))
  261. }
  262. assert.Equal(t, expectedEntrypoint, sb.state.runConfig.Entrypoint)
  263. }
  264. func TestExpose(t *testing.T) {
  265. b := newBuilderWithMockBackend()
  266. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  267. exposedPort := "80"
  268. cmd := &instructions.ExposeCommand{
  269. Ports: []string{exposedPort},
  270. }
  271. err := dispatch(sb, cmd)
  272. require.NoError(t, err)
  273. require.NotNil(t, sb.state.runConfig.ExposedPorts)
  274. require.Len(t, sb.state.runConfig.ExposedPorts, 1)
  275. portsMapping, err := nat.ParsePortSpec(exposedPort)
  276. require.NoError(t, err)
  277. assert.Contains(t, sb.state.runConfig.ExposedPorts, portsMapping[0].Port)
  278. }
  279. func TestUser(t *testing.T) {
  280. b := newBuilderWithMockBackend()
  281. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  282. cmd := &instructions.UserCommand{
  283. User: "test",
  284. }
  285. err := dispatch(sb, cmd)
  286. require.NoError(t, err)
  287. assert.Equal(t, "test", sb.state.runConfig.User)
  288. }
  289. func TestVolume(t *testing.T) {
  290. b := newBuilderWithMockBackend()
  291. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  292. exposedVolume := "/foo"
  293. cmd := &instructions.VolumeCommand{
  294. Volumes: []string{exposedVolume},
  295. }
  296. err := dispatch(sb, cmd)
  297. require.NoError(t, err)
  298. require.NotNil(t, sb.state.runConfig.Volumes)
  299. assert.Len(t, sb.state.runConfig.Volumes, 1)
  300. assert.Contains(t, sb.state.runConfig.Volumes, exposedVolume)
  301. }
  302. func TestStopSignal(t *testing.T) {
  303. if runtime.GOOS == "windows" {
  304. t.Skip("Windows does not support stopsignal")
  305. return
  306. }
  307. b := newBuilderWithMockBackend()
  308. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  309. signal := "SIGKILL"
  310. cmd := &instructions.StopSignalCommand{
  311. Signal: signal,
  312. }
  313. err := dispatch(sb, cmd)
  314. require.NoError(t, err)
  315. assert.Equal(t, signal, sb.state.runConfig.StopSignal)
  316. }
  317. func TestArg(t *testing.T) {
  318. b := newBuilderWithMockBackend()
  319. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  320. argName := "foo"
  321. argVal := "bar"
  322. cmd := &instructions.ArgCommand{Key: argName, Value: &argVal}
  323. err := dispatch(sb, cmd)
  324. require.NoError(t, err)
  325. expected := map[string]string{argName: argVal}
  326. assert.Equal(t, expected, sb.state.buildArgs.GetAllAllowed())
  327. }
  328. func TestShell(t *testing.T) {
  329. b := newBuilderWithMockBackend()
  330. sb := newDispatchRequest(b, '`', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
  331. shellCmd := "powershell"
  332. cmd := &instructions.ShellCommand{Shell: strslice.StrSlice{shellCmd}}
  333. err := dispatch(sb, cmd)
  334. require.NoError(t, err)
  335. expectedShell := strslice.StrSlice([]string{shellCmd})
  336. assert.Equal(t, expectedShell, sb.state.runConfig.Shell)
  337. }
  338. func TestPrependEnvOnCmd(t *testing.T) {
  339. buildArgs := newBuildArgs(nil)
  340. buildArgs.AddArg("NO_PROXY", nil)
  341. args := []string{"sorted=nope", "args=not", "http_proxy=foo", "NO_PROXY=YA"}
  342. cmd := []string{"foo", "bar"}
  343. cmdWithEnv := prependEnvOnCmd(buildArgs, args, cmd)
  344. expected := strslice.StrSlice([]string{
  345. "|3", "NO_PROXY=YA", "args=not", "sorted=nope", "foo", "bar"})
  346. assert.Equal(t, expected, cmdWithEnv)
  347. }
  348. func TestRunWithBuildArgs(t *testing.T) {
  349. b := newBuilderWithMockBackend()
  350. args := newBuildArgs(make(map[string]*string))
  351. args.argsFromOptions["HTTP_PROXY"] = strPtr("FOO")
  352. b.disableCommit = false
  353. sb := newDispatchRequest(b, '`', nil, args, newStagesBuildResults())
  354. runConfig := &container.Config{}
  355. origCmd := strslice.StrSlice([]string{"cmd", "in", "from", "image"})
  356. cmdWithShell := strslice.StrSlice(append(getShell(runConfig, runtime.GOOS), "echo foo"))
  357. envVars := []string{"|1", "one=two"}
  358. cachedCmd := strslice.StrSlice(append(envVars, cmdWithShell...))
  359. imageCache := &mockImageCache{
  360. getCacheFunc: func(parentID string, cfg *container.Config) (string, error) {
  361. // Check the runConfig.Cmd sent to probeCache()
  362. assert.Equal(t, cachedCmd, cfg.Cmd)
  363. assert.Equal(t, strslice.StrSlice(nil), cfg.Entrypoint)
  364. return "", nil
  365. },
  366. }
  367. mockBackend := b.docker.(*MockBackend)
  368. mockBackend.makeImageCacheFunc = func(_ []string, _ string) builder.ImageCache {
  369. return imageCache
  370. }
  371. b.imageProber = newImageProber(mockBackend, nil, runtime.GOOS, false)
  372. mockBackend.getImageFunc = func(_ string) (builder.Image, builder.ReleaseableLayer, error) {
  373. return &mockImage{
  374. id: "abcdef",
  375. config: &container.Config{Cmd: origCmd},
  376. }, nil, nil
  377. }
  378. mockBackend.containerCreateFunc = func(config types.ContainerCreateConfig) (container.ContainerCreateCreatedBody, error) {
  379. // Check the runConfig.Cmd sent to create()
  380. assert.Equal(t, cmdWithShell, config.Config.Cmd)
  381. assert.Contains(t, config.Config.Env, "one=two")
  382. assert.Equal(t, strslice.StrSlice{""}, config.Config.Entrypoint)
  383. return container.ContainerCreateCreatedBody{ID: "12345"}, nil
  384. }
  385. mockBackend.commitFunc = func(cID string, cfg *backend.ContainerCommitConfig) (string, error) {
  386. // Check the runConfig.Cmd sent to commit()
  387. assert.Equal(t, origCmd, cfg.Config.Cmd)
  388. assert.Equal(t, cachedCmd, cfg.ContainerConfig.Cmd)
  389. assert.Equal(t, strslice.StrSlice(nil), cfg.Config.Entrypoint)
  390. return "", nil
  391. }
  392. from := &instructions.Stage{BaseName: "abcdef"}
  393. err := initializeStage(sb, from)
  394. require.NoError(t, err)
  395. sb.state.buildArgs.AddArg("one", strPtr("two"))
  396. run := &instructions.RunCommand{
  397. ShellDependantCmdLine: instructions.ShellDependantCmdLine{
  398. CmdLine: strslice.StrSlice{"echo foo"},
  399. PrependShell: true,
  400. },
  401. }
  402. require.NoError(t, dispatch(sb, run))
  403. // Check that runConfig.Cmd has not been modified by run
  404. assert.Equal(t, origCmd, sb.state.runConfig.Cmd)
  405. }