docker_cli_build_test.go 39 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446
  1. package main
  2. import (
  3. "fmt"
  4. "os"
  5. "os/exec"
  6. "path/filepath"
  7. "strings"
  8. "testing"
  9. "time"
  10. )
  11. func TestBuildCacheADD(t *testing.T) {
  12. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildCacheADD", "1")
  13. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcacheadd1", ".")
  14. buildCmd.Dir = buildDirectory
  15. exitCode, err := runCommand(buildCmd)
  16. errorOut(err, t, fmt.Sprintf("build failed to complete: %v", err))
  17. if err != nil || exitCode != 0 {
  18. t.Fatal("failed to build the image")
  19. }
  20. buildDirectory = filepath.Join(workingDirectory, "build_tests", "TestBuildCacheADD", "2")
  21. buildCmd = exec.Command(dockerBinary, "build", "-t", "testcacheadd2", ".")
  22. buildCmd.Dir = buildDirectory
  23. out, exitCode, err := runCommandWithOutput(buildCmd)
  24. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  25. if err != nil || exitCode != 0 {
  26. t.Fatal("failed to build the image")
  27. }
  28. if strings.Contains(out, "Using cache") {
  29. t.Fatal("2nd build used cache on ADD, it shouldn't")
  30. }
  31. deleteImages("testcacheadd1")
  32. deleteImages("testcacheadd2")
  33. logDone("build - build two images with ADD")
  34. }
  35. func TestBuildSixtySteps(t *testing.T) {
  36. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildSixtySteps")
  37. buildCmd := exec.Command(dockerBinary, "build", "-t", "foobuildsixtysteps", ".")
  38. buildCmd.Dir = buildDirectory
  39. out, exitCode, err := runCommandWithOutput(buildCmd)
  40. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  41. if err != nil || exitCode != 0 {
  42. t.Fatal("failed to build the image")
  43. }
  44. deleteImages("foobuildsixtysteps")
  45. logDone("build - build an image with sixty build steps")
  46. }
  47. func TestAddSingleFileToRoot(t *testing.T) {
  48. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd", "SingleFileToRoot")
  49. f, err := os.OpenFile(filepath.Join(buildDirectory, "test_file"), os.O_CREATE, 0644)
  50. if err != nil {
  51. t.Fatal(err)
  52. }
  53. f.Close()
  54. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", ".")
  55. buildCmd.Dir = buildDirectory
  56. out, exitCode, err := runCommandWithOutput(buildCmd)
  57. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  58. if err != nil || exitCode != 0 {
  59. t.Fatal("failed to build the image")
  60. }
  61. deleteImages("testaddimg")
  62. logDone("build - add single file to root")
  63. }
  64. // Issue #3960: "ADD src ." hangs
  65. func TestAddSingleFileToWorkdir(t *testing.T) {
  66. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd", "SingleFileToWorkdir")
  67. f, err := os.OpenFile(filepath.Join(buildDirectory, "test_file"), os.O_CREATE, 0644)
  68. if err != nil {
  69. t.Fatal(err)
  70. }
  71. f.Close()
  72. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", ".")
  73. buildCmd.Dir = buildDirectory
  74. done := make(chan error)
  75. go func() {
  76. out, exitCode, err := runCommandWithOutput(buildCmd)
  77. if err != nil || exitCode != 0 {
  78. done <- fmt.Errorf("build failed to complete: %s %v", out, err)
  79. return
  80. }
  81. done <- nil
  82. }()
  83. select {
  84. case <-time.After(5 * time.Second):
  85. if err := buildCmd.Process.Kill(); err != nil {
  86. fmt.Printf("could not kill build (pid=%d): %v\n", buildCmd.Process.Pid, err)
  87. }
  88. t.Fatal("build timed out")
  89. case err := <-done:
  90. if err != nil {
  91. t.Fatal(err)
  92. }
  93. }
  94. deleteImages("testaddimg")
  95. logDone("build - add single file to workdir")
  96. }
  97. func TestAddSingleFileToExistDir(t *testing.T) {
  98. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd")
  99. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", "SingleFileToExistDir")
  100. buildCmd.Dir = buildDirectory
  101. out, exitCode, err := runCommandWithOutput(buildCmd)
  102. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  103. if err != nil || exitCode != 0 {
  104. t.Fatal("failed to build the image")
  105. }
  106. deleteImages("testaddimg")
  107. logDone("build - add single file to existing dir")
  108. }
  109. func TestAddSingleFileToNonExistDir(t *testing.T) {
  110. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd")
  111. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", "SingleFileToNonExistDir")
  112. buildCmd.Dir = buildDirectory
  113. out, exitCode, err := runCommandWithOutput(buildCmd)
  114. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  115. if err != nil || exitCode != 0 {
  116. t.Fatal("failed to build the image")
  117. }
  118. deleteImages("testaddimg")
  119. logDone("build - add single file to non-existing dir")
  120. }
  121. func TestAddDirContentToRoot(t *testing.T) {
  122. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd")
  123. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", "DirContentToRoot")
  124. buildCmd.Dir = buildDirectory
  125. out, exitCode, err := runCommandWithOutput(buildCmd)
  126. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  127. if err != nil || exitCode != 0 {
  128. t.Fatal("failed to build the image")
  129. }
  130. deleteImages("testaddimg")
  131. logDone("build - add directory contents to root")
  132. }
  133. func TestAddDirContentToExistDir(t *testing.T) {
  134. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd")
  135. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", "DirContentToExistDir")
  136. buildCmd.Dir = buildDirectory
  137. out, exitCode, err := runCommandWithOutput(buildCmd)
  138. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  139. if err != nil || exitCode != 0 {
  140. t.Fatal("failed to build the image")
  141. }
  142. deleteImages("testaddimg")
  143. logDone("build - add directory contents to existing dir")
  144. }
  145. func TestAddWholeDirToRoot(t *testing.T) {
  146. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd", "WholeDirToRoot")
  147. test_dir := filepath.Join(buildDirectory, "test_dir")
  148. if err := os.MkdirAll(test_dir, 0755); err != nil {
  149. t.Fatal(err)
  150. }
  151. f, err := os.OpenFile(filepath.Join(test_dir, "test_file"), os.O_CREATE, 0644)
  152. if err != nil {
  153. t.Fatal(err)
  154. }
  155. f.Close()
  156. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", ".")
  157. buildCmd.Dir = buildDirectory
  158. out, exitCode, err := runCommandWithOutput(buildCmd)
  159. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  160. if err != nil || exitCode != 0 {
  161. t.Fatal("failed to build the image")
  162. }
  163. deleteImages("testaddimg")
  164. logDone("build - add whole directory to root")
  165. }
  166. func TestAddEtcToRoot(t *testing.T) {
  167. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestAdd")
  168. buildCmd := exec.Command(dockerBinary, "build", "-t", "testaddimg", "EtcToRoot")
  169. buildCmd.Dir = buildDirectory
  170. out, exitCode, err := runCommandWithOutput(buildCmd)
  171. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  172. if err != nil || exitCode != 0 {
  173. t.Fatal("failed to build the image")
  174. }
  175. deleteImages("testaddimg")
  176. logDone("build - add etc directory to root")
  177. }
  178. func TestCopySingleFileToRoot(t *testing.T) {
  179. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy", "SingleFileToRoot")
  180. f, err := os.OpenFile(filepath.Join(buildDirectory, "test_file"), os.O_CREATE, 0644)
  181. if err != nil {
  182. t.Fatal(err)
  183. }
  184. f.Close()
  185. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", ".")
  186. buildCmd.Dir = buildDirectory
  187. out, exitCode, err := runCommandWithOutput(buildCmd)
  188. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  189. if err != nil || exitCode != 0 {
  190. t.Fatal("failed to build the image")
  191. }
  192. deleteImages("testcopyimg")
  193. logDone("build - copy single file to root")
  194. }
  195. // Issue #3960: "ADD src ." hangs - adapted for COPY
  196. func TestCopySingleFileToWorkdir(t *testing.T) {
  197. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy", "SingleFileToWorkdir")
  198. f, err := os.OpenFile(filepath.Join(buildDirectory, "test_file"), os.O_CREATE, 0644)
  199. if err != nil {
  200. t.Fatal(err)
  201. }
  202. f.Close()
  203. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", ".")
  204. buildCmd.Dir = buildDirectory
  205. done := make(chan error)
  206. go func() {
  207. out, exitCode, err := runCommandWithOutput(buildCmd)
  208. if err != nil || exitCode != 0 {
  209. done <- fmt.Errorf("build failed to complete: %s %v", out, err)
  210. return
  211. }
  212. done <- nil
  213. }()
  214. select {
  215. case <-time.After(5 * time.Second):
  216. if err := buildCmd.Process.Kill(); err != nil {
  217. fmt.Printf("could not kill build (pid=%d): %v\n", buildCmd.Process.Pid, err)
  218. }
  219. t.Fatal("build timed out")
  220. case err := <-done:
  221. if err != nil {
  222. t.Fatal(err)
  223. }
  224. }
  225. deleteImages("testcopyimg")
  226. logDone("build - copy single file to workdir")
  227. }
  228. func TestCopySingleFileToExistDir(t *testing.T) {
  229. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  230. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "SingleFileToExistDir")
  231. buildCmd.Dir = buildDirectory
  232. out, exitCode, err := runCommandWithOutput(buildCmd)
  233. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  234. if err != nil || exitCode != 0 {
  235. t.Fatal("failed to build the image")
  236. }
  237. deleteImages("testcopyimg")
  238. logDone("build - add single file to existing dir")
  239. }
  240. func TestCopySingleFileToNonExistDir(t *testing.T) {
  241. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  242. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "SingleFileToNonExistDir")
  243. buildCmd.Dir = buildDirectory
  244. out, exitCode, err := runCommandWithOutput(buildCmd)
  245. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  246. if err != nil || exitCode != 0 {
  247. t.Fatal("failed to build the image")
  248. }
  249. deleteImages("testcopyimg")
  250. logDone("build - copy single file to non-existing dir")
  251. }
  252. func TestCopyDirContentToRoot(t *testing.T) {
  253. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  254. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "DirContentToRoot")
  255. buildCmd.Dir = buildDirectory
  256. out, exitCode, err := runCommandWithOutput(buildCmd)
  257. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  258. if err != nil || exitCode != 0 {
  259. t.Fatal("failed to build the image")
  260. }
  261. deleteImages("testcopyimg")
  262. logDone("build - copy directory contents to root")
  263. }
  264. func TestCopyDirContentToExistDir(t *testing.T) {
  265. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  266. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "DirContentToExistDir")
  267. buildCmd.Dir = buildDirectory
  268. out, exitCode, err := runCommandWithOutput(buildCmd)
  269. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  270. if err != nil || exitCode != 0 {
  271. t.Fatal("failed to build the image")
  272. }
  273. deleteImages("testcopyimg")
  274. logDone("build - copy directory contents to existing dir")
  275. }
  276. func TestCopyWholeDirToRoot(t *testing.T) {
  277. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy", "WholeDirToRoot")
  278. test_dir := filepath.Join(buildDirectory, "test_dir")
  279. if err := os.MkdirAll(test_dir, 0755); err != nil {
  280. t.Fatal(err)
  281. }
  282. f, err := os.OpenFile(filepath.Join(test_dir, "test_file"), os.O_CREATE, 0644)
  283. if err != nil {
  284. t.Fatal(err)
  285. }
  286. f.Close()
  287. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", ".")
  288. buildCmd.Dir = buildDirectory
  289. out, exitCode, err := runCommandWithOutput(buildCmd)
  290. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  291. if err != nil || exitCode != 0 {
  292. t.Fatal("failed to build the image")
  293. }
  294. deleteImages("testcopyimg")
  295. logDone("build - copy whole directory to root")
  296. }
  297. func TestCopyEtcToRoot(t *testing.T) {
  298. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  299. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "EtcToRoot")
  300. buildCmd.Dir = buildDirectory
  301. out, exitCode, err := runCommandWithOutput(buildCmd)
  302. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out, err))
  303. if err != nil || exitCode != 0 {
  304. t.Fatal("failed to build the image")
  305. }
  306. deleteImages("testcopyimg")
  307. logDone("build - copy etc directory to root")
  308. }
  309. func TestCopyDisallowRemote(t *testing.T) {
  310. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestCopy")
  311. buildCmd := exec.Command(dockerBinary, "build", "-t", "testcopyimg", "DisallowRemote")
  312. buildCmd.Dir = buildDirectory
  313. out, exitCode, err := runCommandWithOutput(buildCmd)
  314. if err == nil || exitCode == 0 {
  315. t.Fatalf("building the image should've failed; output: %s", out)
  316. }
  317. deleteImages("testcopyimg")
  318. logDone("build - copy - disallow copy from remote")
  319. }
  320. // Issue #5270 - ensure we throw a better error than "unexpected EOF"
  321. // when we can't access files in the context.
  322. func TestBuildWithInaccessibleFilesInContext(t *testing.T) {
  323. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildWithInaccessibleFilesInContext")
  324. {
  325. // This is used to ensure we detect inaccessible files early during build in the cli client
  326. pathToInaccessibleFileBuildDirectory := filepath.Join(buildDirectory, "inaccessiblefile")
  327. pathToFileWithoutReadAccess := filepath.Join(pathToInaccessibleFileBuildDirectory, "fileWithoutReadAccess")
  328. err := os.Chown(pathToFileWithoutReadAccess, 0, 0)
  329. errorOut(err, t, fmt.Sprintf("failed to chown file to root: %s", err))
  330. err = os.Chmod(pathToFileWithoutReadAccess, 0700)
  331. errorOut(err, t, fmt.Sprintf("failed to chmod file to 700: %s", err))
  332. buildCommandStatement := fmt.Sprintf("%s build -t inaccessiblefiles .", dockerBinary)
  333. buildCmd := exec.Command("su", "unprivilegeduser", "-c", buildCommandStatement)
  334. buildCmd.Dir = pathToInaccessibleFileBuildDirectory
  335. out, exitCode, err := runCommandWithOutput(buildCmd)
  336. if err == nil || exitCode == 0 {
  337. t.Fatalf("build should have failed: %s %s", err, out)
  338. }
  339. // check if we've detected the failure before we started building
  340. if !strings.Contains(out, "no permission to read from ") {
  341. t.Fatalf("output should've contained the string: no permission to read from but contained: %s", out)
  342. }
  343. if !strings.Contains(out, "Error checking context is accessible") {
  344. t.Fatalf("output should've contained the string: Error checking context is accessible")
  345. }
  346. }
  347. {
  348. // This is used to ensure we detect inaccessible directories early during build in the cli client
  349. pathToInaccessibleDirectoryBuildDirectory := filepath.Join(buildDirectory, "inaccessibledirectory")
  350. pathToDirectoryWithoutReadAccess := filepath.Join(pathToInaccessibleDirectoryBuildDirectory, "directoryWeCantStat")
  351. pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")
  352. err := os.Chown(pathToDirectoryWithoutReadAccess, 0, 0)
  353. errorOut(err, t, fmt.Sprintf("failed to chown directory to root: %s", err))
  354. err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444)
  355. errorOut(err, t, fmt.Sprintf("failed to chmod directory to 755: %s", err))
  356. err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700)
  357. errorOut(err, t, fmt.Sprintf("failed to chmod file to 444: %s", err))
  358. buildCommandStatement := fmt.Sprintf("%s build -t inaccessiblefiles .", dockerBinary)
  359. buildCmd := exec.Command("su", "unprivilegeduser", "-c", buildCommandStatement)
  360. buildCmd.Dir = pathToInaccessibleDirectoryBuildDirectory
  361. out, exitCode, err := runCommandWithOutput(buildCmd)
  362. if err == nil || exitCode == 0 {
  363. t.Fatalf("build should have failed: %s %s", err, out)
  364. }
  365. // check if we've detected the failure before we started building
  366. if !strings.Contains(out, "can't stat") {
  367. t.Fatalf("output should've contained the string: can't access %s", out)
  368. }
  369. if !strings.Contains(out, "Error checking context is accessible") {
  370. t.Fatalf("output should've contained the string: Error checking context is accessible")
  371. }
  372. }
  373. {
  374. // This is used to ensure we don't follow links when checking if everything in the context is accessible
  375. // This test doesn't require that we run commands as an unprivileged user
  376. pathToDirectoryWhichContainsLinks := filepath.Join(buildDirectory, "linksdirectory")
  377. buildCmd := exec.Command(dockerBinary, "build", "-t", "testlinksok", ".")
  378. buildCmd.Dir = pathToDirectoryWhichContainsLinks
  379. out, exitCode, err := runCommandWithOutput(buildCmd)
  380. if err != nil || exitCode != 0 {
  381. t.Fatalf("build should have worked: %s %s", err, out)
  382. }
  383. deleteImages("testlinksok")
  384. }
  385. deleteImages("inaccessiblefiles")
  386. logDone("build - ADD from context with inaccessible files must fail")
  387. logDone("build - ADD from context with accessible links must work")
  388. }
  389. func TestBuildForceRm(t *testing.T) {
  390. containerCountBefore, err := getContainerCount()
  391. if err != nil {
  392. t.Fatalf("failed to get the container count: %s", err)
  393. }
  394. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildForceRm")
  395. buildCmd := exec.Command(dockerBinary, "build", "--force-rm", ".")
  396. buildCmd.Dir = buildDirectory
  397. _, exitCode, err := runCommandWithOutput(buildCmd)
  398. if err == nil || exitCode == 0 {
  399. t.Fatal("failed to build the image")
  400. }
  401. containerCountAfter, err := getContainerCount()
  402. if err != nil {
  403. t.Fatalf("failed to get the container count: %s", err)
  404. }
  405. if containerCountBefore != containerCountAfter {
  406. t.Fatalf("--force-rm shouldn't have left containers behind")
  407. }
  408. logDone("build - ensure --force-rm doesn't leave containers behind")
  409. }
  410. func TestBuildRm(t *testing.T) {
  411. {
  412. containerCountBefore, err := getContainerCount()
  413. if err != nil {
  414. t.Fatalf("failed to get the container count: %s", err)
  415. }
  416. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildRm")
  417. buildCmd := exec.Command(dockerBinary, "build", "--rm", "-t", "testbuildrm", ".")
  418. buildCmd.Dir = buildDirectory
  419. _, exitCode, err := runCommandWithOutput(buildCmd)
  420. if err != nil || exitCode != 0 {
  421. t.Fatal("failed to build the image")
  422. }
  423. containerCountAfter, err := getContainerCount()
  424. if err != nil {
  425. t.Fatalf("failed to get the container count: %s", err)
  426. }
  427. if containerCountBefore != containerCountAfter {
  428. t.Fatalf("-rm shouldn't have left containers behind")
  429. }
  430. deleteImages("testbuildrm")
  431. }
  432. {
  433. containerCountBefore, err := getContainerCount()
  434. if err != nil {
  435. t.Fatalf("failed to get the container count: %s", err)
  436. }
  437. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildRm")
  438. buildCmd := exec.Command(dockerBinary, "build", "-t", "testbuildrm", ".")
  439. buildCmd.Dir = buildDirectory
  440. _, exitCode, err := runCommandWithOutput(buildCmd)
  441. if err != nil || exitCode != 0 {
  442. t.Fatal("failed to build the image")
  443. }
  444. containerCountAfter, err := getContainerCount()
  445. if err != nil {
  446. t.Fatalf("failed to get the container count: %s", err)
  447. }
  448. if containerCountBefore != containerCountAfter {
  449. t.Fatalf("--rm shouldn't have left containers behind")
  450. }
  451. deleteImages("testbuildrm")
  452. }
  453. {
  454. containerCountBefore, err := getContainerCount()
  455. if err != nil {
  456. t.Fatalf("failed to get the container count: %s", err)
  457. }
  458. buildDirectory := filepath.Join(workingDirectory, "build_tests", "TestBuildRm")
  459. buildCmd := exec.Command(dockerBinary, "build", "--rm=false", "-t", "testbuildrm", ".")
  460. buildCmd.Dir = buildDirectory
  461. _, exitCode, err := runCommandWithOutput(buildCmd)
  462. if err != nil || exitCode != 0 {
  463. t.Fatal("failed to build the image")
  464. }
  465. containerCountAfter, err := getContainerCount()
  466. if err != nil {
  467. t.Fatalf("failed to get the container count: %s", err)
  468. }
  469. if containerCountBefore == containerCountAfter {
  470. t.Fatalf("--rm=false should have left containers behind")
  471. }
  472. deleteAllContainers()
  473. deleteImages("testbuildrm")
  474. }
  475. logDone("build - ensure --rm doesn't leave containers behind and that --rm=true is the default")
  476. logDone("build - ensure --rm=false overrides the default")
  477. }
  478. func TestBuildWithVolumes(t *testing.T) {
  479. name := "testbuildvolumes"
  480. expected := "map[/test1:map[] /test2:map[]]"
  481. defer deleteImages(name)
  482. _, err := buildImage(name,
  483. `FROM scratch
  484. VOLUME /test1
  485. VOLUME /test2`,
  486. true)
  487. if err != nil {
  488. t.Fatal(err)
  489. }
  490. res, err := inspectField(name, "Config.Volumes")
  491. if err != nil {
  492. t.Fatal(err)
  493. }
  494. if res != expected {
  495. t.Fatalf("Volumes %s, expected %s", res, expected)
  496. }
  497. logDone("build - with volumes")
  498. }
  499. func TestBuildMaintainer(t *testing.T) {
  500. name := "testbuildmaintainer"
  501. expected := "dockerio"
  502. defer deleteImages(name)
  503. _, err := buildImage(name,
  504. `FROM scratch
  505. MAINTAINER dockerio`,
  506. true)
  507. if err != nil {
  508. t.Fatal(err)
  509. }
  510. res, err := inspectField(name, "Author")
  511. if err != nil {
  512. t.Fatal(err)
  513. }
  514. if res != expected {
  515. t.Fatalf("Maintainer %s, expected %s", res, expected)
  516. }
  517. logDone("build - maintainer")
  518. }
  519. func TestBuildUser(t *testing.T) {
  520. name := "testbuilduser"
  521. expected := "dockerio"
  522. defer deleteImages(name)
  523. _, err := buildImage(name,
  524. `FROM busybox
  525. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  526. USER dockerio
  527. RUN [ $(whoami) = 'dockerio' ]`,
  528. true)
  529. if err != nil {
  530. t.Fatal(err)
  531. }
  532. res, err := inspectField(name, "Config.User")
  533. if err != nil {
  534. t.Fatal(err)
  535. }
  536. if res != expected {
  537. t.Fatalf("User %s, expected %s", res, expected)
  538. }
  539. logDone("build - user")
  540. }
  541. func TestBuildRelativeWorkdir(t *testing.T) {
  542. name := "testbuildrelativeworkdir"
  543. expected := "/test2/test3"
  544. defer deleteImages(name)
  545. _, err := buildImage(name,
  546. `FROM busybox
  547. RUN [ "$PWD" = '/' ]
  548. WORKDIR test1
  549. RUN [ "$PWD" = '/test1' ]
  550. WORKDIR /test2
  551. RUN [ "$PWD" = '/test2' ]
  552. WORKDIR test3
  553. RUN [ "$PWD" = '/test2/test3' ]`,
  554. true)
  555. if err != nil {
  556. t.Fatal(err)
  557. }
  558. res, err := inspectField(name, "Config.WorkingDir")
  559. if err != nil {
  560. t.Fatal(err)
  561. }
  562. if res != expected {
  563. t.Fatalf("Workdir %s, expected %s", res, expected)
  564. }
  565. logDone("build - relative workdir")
  566. }
  567. func TestBuildEnv(t *testing.T) {
  568. name := "testbuildenv"
  569. expected := "[HOME=/ PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin PORT=2375]"
  570. defer deleteImages(name)
  571. _, err := buildImage(name,
  572. `FROM busybox
  573. ENV PORT 2375
  574. RUN [ $(env | grep PORT) = 'PORT=2375' ]`,
  575. true)
  576. if err != nil {
  577. t.Fatal(err)
  578. }
  579. res, err := inspectField(name, "Config.Env")
  580. if err != nil {
  581. t.Fatal(err)
  582. }
  583. if res != expected {
  584. t.Fatalf("Env %s, expected %s", res, expected)
  585. }
  586. logDone("build - env")
  587. }
  588. func TestBuildCmd(t *testing.T) {
  589. name := "testbuildcmd"
  590. expected := "[/bin/echo Hello World]"
  591. defer deleteImages(name)
  592. _, err := buildImage(name,
  593. `FROM scratch
  594. CMD ["/bin/echo", "Hello World"]`,
  595. true)
  596. if err != nil {
  597. t.Fatal(err)
  598. }
  599. res, err := inspectField(name, "Config.Cmd")
  600. if err != nil {
  601. t.Fatal(err)
  602. }
  603. if res != expected {
  604. t.Fatalf("Cmd %s, expected %s", res, expected)
  605. }
  606. logDone("build - cmd")
  607. }
  608. func TestBuildExpose(t *testing.T) {
  609. name := "testbuildexpose"
  610. expected := "map[2375/tcp:map[]]"
  611. defer deleteImages(name)
  612. _, err := buildImage(name,
  613. `FROM scratch
  614. EXPOSE 2375`,
  615. true)
  616. if err != nil {
  617. t.Fatal(err)
  618. }
  619. res, err := inspectField(name, "Config.ExposedPorts")
  620. if err != nil {
  621. t.Fatal(err)
  622. }
  623. if res != expected {
  624. t.Fatalf("Exposed ports %s, expected %s", res, expected)
  625. }
  626. logDone("build - expose")
  627. }
  628. func TestBuildEntrypoint(t *testing.T) {
  629. name := "testbuildentrypoint"
  630. expected := "[/bin/echo]"
  631. defer deleteImages(name)
  632. _, err := buildImage(name,
  633. `FROM scratch
  634. ENTRYPOINT ["/bin/echo"]`,
  635. true)
  636. if err != nil {
  637. t.Fatal(err)
  638. }
  639. res, err := inspectField(name, "Config.Entrypoint")
  640. if err != nil {
  641. t.Fatal(err)
  642. }
  643. if res != expected {
  644. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  645. }
  646. logDone("build - entrypoint")
  647. }
  648. // #6445 ensure ONBUILD triggers aren't committed to grandchildren
  649. func TestBuildOnBuildLimitedInheritence(t *testing.T) {
  650. name1 := "testonbuildtrigger1"
  651. dockerfile1 := `
  652. FROM busybox
  653. RUN echo "GRANDPARENT"
  654. ONBUILD RUN echo "ONBUILD PARENT"
  655. `
  656. ctx1, err := fakeContext(dockerfile1, nil)
  657. if err != nil {
  658. t.Fatal(err)
  659. }
  660. buildCmd := exec.Command(dockerBinary, "build", "-t", name1, ".")
  661. buildCmd.Dir = ctx1.Dir
  662. out1, _, err := runCommandWithOutput(buildCmd)
  663. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out1, err))
  664. defer deleteImages(name1)
  665. name2 := "testonbuildtrigger2"
  666. dockerfile2 := `
  667. FROM testonbuildtrigger1
  668. `
  669. ctx2, err := fakeContext(dockerfile2, nil)
  670. if err != nil {
  671. t.Fatal(err)
  672. }
  673. buildCmd = exec.Command(dockerBinary, "build", "-t", name2, ".")
  674. buildCmd.Dir = ctx2.Dir
  675. out2, _, err := runCommandWithOutput(buildCmd)
  676. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out2, err))
  677. defer deleteImages(name2)
  678. name3 := "testonbuildtrigger3"
  679. dockerfile3 := `
  680. FROM testonbuildtrigger2
  681. `
  682. ctx3, err := fakeContext(dockerfile3, nil)
  683. if err != nil {
  684. t.Fatal(err)
  685. }
  686. buildCmd = exec.Command(dockerBinary, "build", "-t", name3, ".")
  687. buildCmd.Dir = ctx3.Dir
  688. out3, _, err := runCommandWithOutput(buildCmd)
  689. errorOut(err, t, fmt.Sprintf("build failed to complete: %v %v", out3, err))
  690. defer deleteImages(name3)
  691. // ONBUILD should be run in second build.
  692. if !strings.Contains(out2, "ONBUILD PARENT") {
  693. t.Fatalf("ONBUILD instruction did not run in child of ONBUILD parent")
  694. }
  695. // ONBUILD should *not* be run in third build.
  696. if strings.Contains(out3, "ONBUILD PARENT") {
  697. t.Fatalf("ONBUILD instruction ran in grandchild of ONBUILD parent")
  698. }
  699. logDone("build - onbuild")
  700. }
  701. func TestBuildWithCache(t *testing.T) {
  702. name := "testbuildwithcache"
  703. defer deleteImages(name)
  704. id1, err := buildImage(name,
  705. `FROM scratch
  706. MAINTAINER dockerio
  707. EXPOSE 5432
  708. ENTRYPOINT ["/bin/echo"]`,
  709. true)
  710. if err != nil {
  711. t.Fatal(err)
  712. }
  713. id2, err := buildImage(name,
  714. `FROM scratch
  715. MAINTAINER dockerio
  716. EXPOSE 5432
  717. ENTRYPOINT ["/bin/echo"]`,
  718. true)
  719. if err != nil {
  720. t.Fatal(err)
  721. }
  722. if id1 != id2 {
  723. t.Fatal("The cache should have been used but hasn't.")
  724. }
  725. logDone("build - with cache")
  726. }
  727. func TestBuildWithoutCache(t *testing.T) {
  728. name := "testbuildwithoutcache"
  729. defer deleteImages(name)
  730. id1, err := buildImage(name,
  731. `FROM scratch
  732. MAINTAINER dockerio
  733. EXPOSE 5432
  734. ENTRYPOINT ["/bin/echo"]`,
  735. true)
  736. if err != nil {
  737. t.Fatal(err)
  738. }
  739. id2, err := buildImage(name,
  740. `FROM scratch
  741. MAINTAINER dockerio
  742. EXPOSE 5432
  743. ENTRYPOINT ["/bin/echo"]`,
  744. false)
  745. if err != nil {
  746. t.Fatal(err)
  747. }
  748. if id1 == id2 {
  749. t.Fatal("The cache should have been invalided but hasn't.")
  750. }
  751. logDone("build - without cache")
  752. }
  753. func TestBuildADDLocalFileWithCache(t *testing.T) {
  754. name := "testbuildaddlocalfilewithcache"
  755. defer deleteImages(name)
  756. dockerfile := `
  757. FROM busybox
  758. MAINTAINER dockerio
  759. ADD foo /usr/lib/bla/bar
  760. RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
  761. ctx, err := fakeContext(dockerfile, map[string]string{
  762. "foo": "hello",
  763. })
  764. defer ctx.Close()
  765. if err != nil {
  766. t.Fatal(err)
  767. }
  768. id1, err := buildImageFromContext(name, ctx, true)
  769. if err != nil {
  770. t.Fatal(err)
  771. }
  772. id2, err := buildImageFromContext(name, ctx, true)
  773. if err != nil {
  774. t.Fatal(err)
  775. }
  776. if id1 != id2 {
  777. t.Fatal("The cache should have been used but hasn't.")
  778. }
  779. logDone("build - add local file with cache")
  780. }
  781. func TestBuildADDLocalFileWithoutCache(t *testing.T) {
  782. name := "testbuildaddlocalfilewithoutcache"
  783. defer deleteImages(name)
  784. dockerfile := `
  785. FROM busybox
  786. MAINTAINER dockerio
  787. ADD foo /usr/lib/bla/bar
  788. RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
  789. ctx, err := fakeContext(dockerfile, map[string]string{
  790. "foo": "hello",
  791. })
  792. defer ctx.Close()
  793. if err != nil {
  794. t.Fatal(err)
  795. }
  796. id1, err := buildImageFromContext(name, ctx, true)
  797. if err != nil {
  798. t.Fatal(err)
  799. }
  800. id2, err := buildImageFromContext(name, ctx, false)
  801. if err != nil {
  802. t.Fatal(err)
  803. }
  804. if id1 == id2 {
  805. t.Fatal("The cache should have been invalided but hasn't.")
  806. }
  807. logDone("build - add local file without cache")
  808. }
  809. func TestBuildADDCurrentDirWithCache(t *testing.T) {
  810. name := "testbuildaddcurrentdirwithcache"
  811. defer deleteImages(name)
  812. dockerfile := `
  813. FROM scratch
  814. MAINTAINER dockerio
  815. ADD . /usr/lib/bla`
  816. ctx, err := fakeContext(dockerfile, map[string]string{
  817. "foo": "hello",
  818. })
  819. defer ctx.Close()
  820. if err != nil {
  821. t.Fatal(err)
  822. }
  823. id1, err := buildImageFromContext(name, ctx, true)
  824. if err != nil {
  825. t.Fatal(err)
  826. }
  827. // Check that adding file invalidate cache of "ADD ."
  828. if err := ctx.Add("bar", "hello2"); err != nil {
  829. t.Fatal(err)
  830. }
  831. id2, err := buildImageFromContext(name, ctx, true)
  832. if err != nil {
  833. t.Fatal(err)
  834. }
  835. if id1 == id2 {
  836. t.Fatal("The cache should have been invalided but hasn't.")
  837. }
  838. // Check that changing file invalidate cache of "ADD ."
  839. if err := ctx.Add("foo", "hello1"); err != nil {
  840. t.Fatal(err)
  841. }
  842. id3, err := buildImageFromContext(name, ctx, true)
  843. if err != nil {
  844. t.Fatal(err)
  845. }
  846. if id2 == id3 {
  847. t.Fatal("The cache should have been invalided but hasn't.")
  848. }
  849. // Check that changing file to same content invalidate cache of "ADD ."
  850. time.Sleep(1 * time.Second) // wait second because of mtime precision
  851. if err := ctx.Add("foo", "hello1"); err != nil {
  852. t.Fatal(err)
  853. }
  854. id4, err := buildImageFromContext(name, ctx, true)
  855. if err != nil {
  856. t.Fatal(err)
  857. }
  858. if id3 == id4 {
  859. t.Fatal("The cache should have been invalided but hasn't.")
  860. }
  861. id5, err := buildImageFromContext(name, ctx, true)
  862. if err != nil {
  863. t.Fatal(err)
  864. }
  865. if id4 != id5 {
  866. t.Fatal("The cache should have been used but hasn't.")
  867. }
  868. logDone("build - add current directory with cache")
  869. }
  870. func TestBuildADDCurrentDirWithoutCache(t *testing.T) {
  871. name := "testbuildaddcurrentdirwithoutcache"
  872. defer deleteImages(name)
  873. dockerfile := `
  874. FROM scratch
  875. MAINTAINER dockerio
  876. ADD . /usr/lib/bla`
  877. ctx, err := fakeContext(dockerfile, map[string]string{
  878. "foo": "hello",
  879. })
  880. defer ctx.Close()
  881. if err != nil {
  882. t.Fatal(err)
  883. }
  884. id1, err := buildImageFromContext(name, ctx, true)
  885. if err != nil {
  886. t.Fatal(err)
  887. }
  888. id2, err := buildImageFromContext(name, ctx, false)
  889. if err != nil {
  890. t.Fatal(err)
  891. }
  892. if id1 == id2 {
  893. t.Fatal("The cache should have been invalided but hasn't.")
  894. }
  895. logDone("build - add current directory without cache")
  896. }
  897. func TestBuildADDRemoteFileWithCache(t *testing.T) {
  898. name := "testbuildaddremotefilewithcache"
  899. defer deleteImages(name)
  900. server, err := fakeStorage(map[string]string{
  901. "baz": "hello",
  902. })
  903. if err != nil {
  904. t.Fatal(err)
  905. }
  906. defer server.Close()
  907. id1, err := buildImage(name,
  908. fmt.Sprintf(`FROM scratch
  909. MAINTAINER dockerio
  910. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  911. true)
  912. if err != nil {
  913. t.Fatal(err)
  914. }
  915. id2, err := buildImage(name,
  916. fmt.Sprintf(`FROM scratch
  917. MAINTAINER dockerio
  918. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  919. true)
  920. if err != nil {
  921. t.Fatal(err)
  922. }
  923. if id1 != id2 {
  924. t.Fatal("The cache should have been used but hasn't.")
  925. }
  926. logDone("build - add remote file with cache")
  927. }
  928. func TestBuildADDRemoteFileWithoutCache(t *testing.T) {
  929. name := "testbuildaddremotefilewithoutcache"
  930. defer deleteImages(name)
  931. server, err := fakeStorage(map[string]string{
  932. "baz": "hello",
  933. })
  934. if err != nil {
  935. t.Fatal(err)
  936. }
  937. defer server.Close()
  938. id1, err := buildImage(name,
  939. fmt.Sprintf(`FROM scratch
  940. MAINTAINER dockerio
  941. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  942. true)
  943. if err != nil {
  944. t.Fatal(err)
  945. }
  946. id2, err := buildImage(name,
  947. fmt.Sprintf(`FROM scratch
  948. MAINTAINER dockerio
  949. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  950. false)
  951. if err != nil {
  952. t.Fatal(err)
  953. }
  954. if id1 == id2 {
  955. t.Fatal("The cache should have been invalided but hasn't.")
  956. }
  957. logDone("build - add remote file without cache")
  958. }
  959. func TestBuildADDLocalAndRemoteFilesWithCache(t *testing.T) {
  960. name := "testbuildaddlocalandremotefilewithcache"
  961. defer deleteImages(name)
  962. server, err := fakeStorage(map[string]string{
  963. "baz": "hello",
  964. })
  965. if err != nil {
  966. t.Fatal(err)
  967. }
  968. defer server.Close()
  969. ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
  970. MAINTAINER dockerio
  971. ADD foo /usr/lib/bla/bar
  972. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  973. map[string]string{
  974. "foo": "hello world",
  975. })
  976. if err != nil {
  977. t.Fatal(err)
  978. }
  979. defer ctx.Close()
  980. id1, err := buildImageFromContext(name, ctx, true)
  981. if err != nil {
  982. t.Fatal(err)
  983. }
  984. id2, err := buildImageFromContext(name, ctx, true)
  985. if err != nil {
  986. t.Fatal(err)
  987. }
  988. if id1 != id2 {
  989. t.Fatal("The cache should have been used but hasn't.")
  990. }
  991. logDone("build - add local and remote file with cache")
  992. }
  993. // TODO: TestCaching
  994. func TestBuildADDLocalAndRemoteFilesWithoutCache(t *testing.T) {
  995. name := "testbuildaddlocalandremotefilewithoutcache"
  996. defer deleteImages(name)
  997. server, err := fakeStorage(map[string]string{
  998. "baz": "hello",
  999. })
  1000. if err != nil {
  1001. t.Fatal(err)
  1002. }
  1003. defer server.Close()
  1004. ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
  1005. MAINTAINER dockerio
  1006. ADD foo /usr/lib/bla/bar
  1007. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  1008. map[string]string{
  1009. "foo": "hello world",
  1010. })
  1011. if err != nil {
  1012. t.Fatal(err)
  1013. }
  1014. defer ctx.Close()
  1015. id1, err := buildImageFromContext(name, ctx, true)
  1016. if err != nil {
  1017. t.Fatal(err)
  1018. }
  1019. id2, err := buildImageFromContext(name, ctx, false)
  1020. if err != nil {
  1021. t.Fatal(err)
  1022. }
  1023. if id1 == id2 {
  1024. t.Fatal("The cache should have been invalided but hasn't.")
  1025. }
  1026. logDone("build - add local and remote file without cache")
  1027. }
  1028. func TestBuildWithVolumeOwnership(t *testing.T) {
  1029. name := "testbuildimg"
  1030. defer deleteImages(name)
  1031. _, err := buildImage(name,
  1032. `FROM busybox:latest
  1033. RUN mkdir /test && chown daemon:daemon /test && chmod 0600 /test
  1034. VOLUME /test`,
  1035. true)
  1036. if err != nil {
  1037. t.Fatal(err)
  1038. }
  1039. cmd := exec.Command(dockerBinary, "run", "--rm", "testbuildimg", "ls", "-la", "/test")
  1040. out, _, err := runCommandWithOutput(cmd)
  1041. if err != nil {
  1042. t.Fatal(err)
  1043. }
  1044. if expected := "drw-------"; !strings.Contains(out, expected) {
  1045. t.Fatalf("expected %s received %s", expected, out)
  1046. }
  1047. if expected := "daemon daemon"; !strings.Contains(out, expected) {
  1048. t.Fatalf("expected %s received %s", expected, out)
  1049. }
  1050. logDone("build - volume ownership")
  1051. }
  1052. // testing #1405 - config.Cmd does not get cleaned up if
  1053. // utilizing cache
  1054. func TestBuildEntrypointRunCleanup(t *testing.T) {
  1055. name := "testbuildcmdcleanup"
  1056. defer deleteImages(name)
  1057. if _, err := buildImage(name,
  1058. `FROM busybox
  1059. RUN echo "hello"`,
  1060. true); err != nil {
  1061. t.Fatal(err)
  1062. }
  1063. ctx, err := fakeContext(`FROM busybox
  1064. RUN echo "hello"
  1065. ADD foo /foo
  1066. ENTRYPOINT ["/bin/echo"]`,
  1067. map[string]string{
  1068. "foo": "hello",
  1069. })
  1070. defer ctx.Close()
  1071. if err != nil {
  1072. t.Fatal(err)
  1073. }
  1074. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1075. t.Fatal(err)
  1076. }
  1077. res, err := inspectField(name, "Config.Cmd")
  1078. if err != nil {
  1079. t.Fatal(err)
  1080. }
  1081. // Cmd inherited from busybox, maybe will be fixed in #5147
  1082. if expected := "[/bin/sh]"; res != expected {
  1083. t.Fatalf("Cmd %s, expected %s", res, expected)
  1084. }
  1085. logDone("build - cleanup cmd after RUN")
  1086. }
  1087. func TestBuldForbiddenContextPath(t *testing.T) {
  1088. name := "testbuildforbidpath"
  1089. defer deleteImages(name)
  1090. ctx, err := fakeContext(`FROM scratch
  1091. ADD ../../ test/
  1092. `,
  1093. map[string]string{
  1094. "test.txt": "test1",
  1095. "other.txt": "other",
  1096. })
  1097. defer ctx.Close()
  1098. if err != nil {
  1099. t.Fatal(err)
  1100. }
  1101. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1102. if !strings.Contains(err.Error(), "Forbidden path outside the build context: ../../ (/)") {
  1103. t.Fatal("Wrong error, must be about forbidden ../../ path")
  1104. }
  1105. } else {
  1106. t.Fatal("Error must not be nil")
  1107. }
  1108. logDone("build - forbidden context path")
  1109. }
  1110. func TestBuildADDFileNotFound(t *testing.T) {
  1111. name := "testbuildaddnotfound"
  1112. defer deleteImages(name)
  1113. ctx, err := fakeContext(`FROM scratch
  1114. ADD foo /usr/local/bar`,
  1115. map[string]string{"bar": "hello"})
  1116. defer ctx.Close()
  1117. if err != nil {
  1118. t.Fatal(err)
  1119. }
  1120. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1121. if !strings.Contains(err.Error(), "foo: no such file or directory") {
  1122. t.Fatalf("Wrong error %v, must be about missing foo file or directory", err)
  1123. }
  1124. } else {
  1125. t.Fatal("Error must not be nil")
  1126. }
  1127. logDone("build - add file not found")
  1128. }
  1129. func TestBuildInheritance(t *testing.T) {
  1130. name := "testbuildinheritance"
  1131. defer deleteImages(name)
  1132. _, err := buildImage(name,
  1133. `FROM scratch
  1134. EXPOSE 2375`,
  1135. true)
  1136. if err != nil {
  1137. t.Fatal(err)
  1138. }
  1139. ports1, err := inspectField(name, "Config.ExposedPorts")
  1140. if err != nil {
  1141. t.Fatal(err)
  1142. }
  1143. _, err = buildImage(name,
  1144. fmt.Sprintf(`FROM %s
  1145. ENTRYPOINT ["/bin/echo"]`, name),
  1146. true)
  1147. if err != nil {
  1148. t.Fatal(err)
  1149. }
  1150. res, err := inspectField(name, "Config.Entrypoint")
  1151. if err != nil {
  1152. t.Fatal(err)
  1153. }
  1154. if expected := "[/bin/echo]"; res != expected {
  1155. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  1156. }
  1157. ports2, err := inspectField(name, "Config.ExposedPorts")
  1158. if err != nil {
  1159. t.Fatal(err)
  1160. }
  1161. if ports1 != ports2 {
  1162. t.Fatalf("Ports must be same: %s != %s", ports1, ports2)
  1163. }
  1164. logDone("build - inheritance")
  1165. }
  1166. func TestBuildFails(t *testing.T) {
  1167. name := "testbuildfails"
  1168. defer deleteImages(name)
  1169. _, err := buildImage(name,
  1170. `FROM busybox
  1171. RUN sh -c "exit 23"`,
  1172. true)
  1173. if err != nil {
  1174. if !strings.Contains(err.Error(), "returned a non-zero code: 23") {
  1175. t.Fatalf("Wrong error %v, must be about non-zero code 23", err)
  1176. }
  1177. } else {
  1178. t.Fatal("Error must not be nil")
  1179. }
  1180. logDone("build - fails")
  1181. }
  1182. func TestBuildFailsDockerfileEmpty(t *testing.T) {
  1183. name := "testbuildfails"
  1184. defer deleteImages(name)
  1185. _, err := buildImage(name, ``, true)
  1186. if err != nil {
  1187. if !strings.Contains(err.Error(), "Dockerfile cannot be empty") {
  1188. t.Fatalf("Wrong error %v, must be about empty Dockerfile", err)
  1189. }
  1190. } else {
  1191. t.Fatal("Error must not be nil")
  1192. }
  1193. logDone("build - fails with empty dockerfile")
  1194. }
  1195. func TestBuildOnBuild(t *testing.T) {
  1196. name := "testbuildonbuild"
  1197. defer deleteImages(name)
  1198. _, err := buildImage(name,
  1199. `FROM busybox
  1200. ONBUILD RUN touch foobar`,
  1201. true)
  1202. if err != nil {
  1203. t.Fatal(err)
  1204. }
  1205. _, err = buildImage(name,
  1206. fmt.Sprintf(`FROM %s
  1207. RUN [ -f foobar ]`, name),
  1208. true)
  1209. if err != nil {
  1210. t.Fatal(err)
  1211. }
  1212. logDone("build - onbuild")
  1213. }
  1214. func TestBuildOnBuildForbiddenChained(t *testing.T) {
  1215. name := "testbuildonbuildforbiddenchained"
  1216. defer deleteImages(name)
  1217. _, err := buildImage(name,
  1218. `FROM busybox
  1219. ONBUILD ONBUILD RUN touch foobar`,
  1220. true)
  1221. if err != nil {
  1222. if !strings.Contains(err.Error(), "Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") {
  1223. t.Fatalf("Wrong error %v, must be about chaining ONBUILD", err)
  1224. }
  1225. } else {
  1226. t.Fatal("Error must not be nil")
  1227. }
  1228. logDone("build - onbuild forbidden chained")
  1229. }
  1230. func TestBuildOnBuildForbiddenFrom(t *testing.T) {
  1231. name := "testbuildonbuildforbiddenfrom"
  1232. defer deleteImages(name)
  1233. _, err := buildImage(name,
  1234. `FROM busybox
  1235. ONBUILD FROM scratch`,
  1236. true)
  1237. if err != nil {
  1238. if !strings.Contains(err.Error(), "FROM isn't allowed as an ONBUILD trigger") {
  1239. t.Fatalf("Wrong error %v, must be about FROM forbidden", err)
  1240. }
  1241. } else {
  1242. t.Fatal("Error must not be nil")
  1243. }
  1244. logDone("build - onbuild forbidden from")
  1245. }
  1246. func TestBuildOnBuildForbiddenMaintainer(t *testing.T) {
  1247. name := "testbuildonbuildforbiddenmaintainer"
  1248. defer deleteImages(name)
  1249. _, err := buildImage(name,
  1250. `FROM busybox
  1251. ONBUILD MAINTAINER docker.io`,
  1252. true)
  1253. if err != nil {
  1254. if !strings.Contains(err.Error(), "MAINTAINER isn't allowed as an ONBUILD trigger") {
  1255. t.Fatalf("Wrong error %v, must be about MAINTAINER forbidden", err)
  1256. }
  1257. } else {
  1258. t.Fatal("Error must not be nil")
  1259. }
  1260. logDone("build - onbuild forbidden maintainer")
  1261. }
  1262. // gh #2446
  1263. func TestBuildAddToSymlinkDest(t *testing.T) {
  1264. name := "testbuildaddtosymlinkdest"
  1265. defer deleteImages(name)
  1266. ctx, err := fakeContext(`FROM busybox
  1267. RUN mkdir /foo
  1268. RUN ln -s /foo /bar
  1269. ADD foo /bar/
  1270. RUN [ -f /bar/foo ]
  1271. RUN [ -f /foo/foo ]`,
  1272. map[string]string{
  1273. "foo": "hello",
  1274. })
  1275. if err != nil {
  1276. t.Fatal(err)
  1277. }
  1278. defer ctx.Close()
  1279. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1280. t.Fatal(err)
  1281. }
  1282. logDone("build - add to symlink destination")
  1283. }