docker_cli_build_test.go 101 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054
  1. package main
  2. import (
  3. "archive/tar"
  4. "bytes"
  5. "encoding/json"
  6. "fmt"
  7. "io/ioutil"
  8. "os"
  9. "os/exec"
  10. "path"
  11. "path/filepath"
  12. "reflect"
  13. "regexp"
  14. "strconv"
  15. "strings"
  16. "syscall"
  17. "testing"
  18. "text/template"
  19. "time"
  20. "github.com/docker/docker/pkg/archive"
  21. )
  22. func TestBuildShCmdJSONEntrypoint(t *testing.T) {
  23. name := "testbuildshcmdjsonentrypoint"
  24. defer deleteImages(name)
  25. _, err := buildImage(
  26. name,
  27. `
  28. FROM busybox
  29. ENTRYPOINT ["/bin/echo"]
  30. CMD echo test
  31. `,
  32. true)
  33. if err != nil {
  34. t.Fatal(err)
  35. }
  36. out, _, err := runCommandWithOutput(
  37. exec.Command(
  38. dockerBinary,
  39. "run",
  40. "--rm",
  41. name))
  42. if err != nil {
  43. t.Fatal(err)
  44. }
  45. if strings.TrimSpace(out) != "/bin/sh -c echo test" {
  46. t.Fatal("CMD did not contain /bin/sh -c")
  47. }
  48. logDone("build - CMD should always contain /bin/sh -c when specified without JSON")
  49. }
  50. func TestBuildEnvironmentReplacementUser(t *testing.T) {
  51. name := "testbuildenvironmentreplacement"
  52. defer deleteImages(name)
  53. _, err := buildImage(name, `
  54. FROM scratch
  55. ENV user foo
  56. USER ${user}
  57. `, true)
  58. if err != nil {
  59. t.Fatal(err)
  60. }
  61. res, err := inspectFieldJSON(name, "Config.User")
  62. if err != nil {
  63. t.Fatal(err)
  64. }
  65. if res != `"foo"` {
  66. t.Fatal("User foo from environment not in Config.User on image")
  67. }
  68. logDone("build - user environment replacement")
  69. }
  70. func TestBuildEnvironmentReplacementVolume(t *testing.T) {
  71. name := "testbuildenvironmentreplacement"
  72. defer deleteImages(name)
  73. _, err := buildImage(name, `
  74. FROM scratch
  75. ENV volume /quux
  76. VOLUME ${volume}
  77. `, true)
  78. if err != nil {
  79. t.Fatal(err)
  80. }
  81. res, err := inspectFieldJSON(name, "Config.Volumes")
  82. if err != nil {
  83. t.Fatal(err)
  84. }
  85. var volumes map[string]interface{}
  86. if err := json.Unmarshal([]byte(res), &volumes); err != nil {
  87. t.Fatal(err)
  88. }
  89. if _, ok := volumes["/quux"]; !ok {
  90. t.Fatal("Volume /quux from environment not in Config.Volumes on image")
  91. }
  92. logDone("build - volume environment replacement")
  93. }
  94. func TestBuildEnvironmentReplacementExpose(t *testing.T) {
  95. name := "testbuildenvironmentreplacement"
  96. defer deleteImages(name)
  97. _, err := buildImage(name, `
  98. FROM scratch
  99. ENV port 80
  100. EXPOSE ${port}
  101. `, true)
  102. if err != nil {
  103. t.Fatal(err)
  104. }
  105. res, err := inspectFieldJSON(name, "Config.ExposedPorts")
  106. if err != nil {
  107. t.Fatal(err)
  108. }
  109. var exposedPorts map[string]interface{}
  110. if err := json.Unmarshal([]byte(res), &exposedPorts); err != nil {
  111. t.Fatal(err)
  112. }
  113. if _, ok := exposedPorts["80/tcp"]; !ok {
  114. t.Fatal("Exposed port 80 from environment not in Config.ExposedPorts on image")
  115. }
  116. logDone("build - expose environment replacement")
  117. }
  118. func TestBuildEnvironmentReplacementWorkdir(t *testing.T) {
  119. name := "testbuildenvironmentreplacement"
  120. defer deleteImages(name)
  121. _, err := buildImage(name, `
  122. FROM busybox
  123. ENV MYWORKDIR /work
  124. RUN mkdir ${MYWORKDIR}
  125. WORKDIR ${MYWORKDIR}
  126. `, true)
  127. if err != nil {
  128. t.Fatal(err)
  129. }
  130. logDone("build - workdir environment replacement")
  131. }
  132. func TestBuildEnvironmentReplacementAddCopy(t *testing.T) {
  133. name := "testbuildenvironmentreplacement"
  134. defer deleteImages(name)
  135. ctx, err := fakeContext(`
  136. FROM scratch
  137. ENV baz foo
  138. ENV quux bar
  139. ENV dot .
  140. ADD ${baz} ${dot}
  141. COPY ${quux} ${dot}
  142. `,
  143. map[string]string{
  144. "foo": "test1",
  145. "bar": "test2",
  146. })
  147. if err != nil {
  148. t.Fatal(err)
  149. }
  150. defer ctx.Close()
  151. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  152. t.Fatal(err)
  153. }
  154. logDone("build - add/copy environment replacement")
  155. }
  156. func TestBuildEnvironmentReplacementEnv(t *testing.T) {
  157. name := "testbuildenvironmentreplacement"
  158. defer deleteImages(name)
  159. _, err := buildImage(name,
  160. `
  161. FROM scratch
  162. ENV foo foo
  163. ENV bar ${foo}
  164. `, true)
  165. if err != nil {
  166. t.Fatal(err)
  167. }
  168. res, err := inspectFieldJSON(name, "Config.Env")
  169. if err != nil {
  170. t.Fatal(err)
  171. }
  172. envResult := []string{}
  173. if err = unmarshalJSON([]byte(res), &envResult); err != nil {
  174. t.Fatal(err)
  175. }
  176. found := false
  177. for _, env := range envResult {
  178. parts := strings.SplitN(env, "=", 2)
  179. if parts[0] == "bar" {
  180. found = true
  181. if parts[1] != "foo" {
  182. t.Fatalf("Could not find replaced var for env `bar`: got %q instead of `foo`", parts[1])
  183. }
  184. }
  185. }
  186. if !found {
  187. t.Fatal("Never found the `bar` env variable")
  188. }
  189. logDone("build - env environment replacement")
  190. }
  191. func TestBuildHandleEscapes(t *testing.T) {
  192. name := "testbuildhandleescapes"
  193. defer deleteImages(name)
  194. _, err := buildImage(name,
  195. `
  196. FROM scratch
  197. ENV FOO bar
  198. VOLUME ${FOO}
  199. `, true)
  200. if err != nil {
  201. t.Fatal(err)
  202. }
  203. var result map[string]map[string]struct{}
  204. res, err := inspectFieldJSON(name, "Config.Volumes")
  205. if err != nil {
  206. t.Fatal(err)
  207. }
  208. if err = unmarshalJSON([]byte(res), &result); err != nil {
  209. t.Fatal(err)
  210. }
  211. if _, ok := result["bar"]; !ok {
  212. t.Fatal("Could not find volume bar set from env foo in volumes table")
  213. }
  214. deleteImages(name)
  215. _, err = buildImage(name,
  216. `
  217. FROM scratch
  218. ENV FOO bar
  219. VOLUME \${FOO}
  220. `, true)
  221. if err != nil {
  222. t.Fatal(err)
  223. }
  224. res, err = inspectFieldJSON(name, "Config.Volumes")
  225. if err != nil {
  226. t.Fatal(err)
  227. }
  228. if err = unmarshalJSON([]byte(res), &result); err != nil {
  229. t.Fatal(err)
  230. }
  231. if _, ok := result["${FOO}"]; !ok {
  232. t.Fatal("Could not find volume ${FOO} set from env foo in volumes table")
  233. }
  234. deleteImages(name)
  235. // this test in particular provides *7* backslashes and expects 6 to come back.
  236. // Like above, the first escape is swallowed and the rest are treated as
  237. // literals, this one is just less obvious because of all the character noise.
  238. _, err = buildImage(name,
  239. `
  240. FROM scratch
  241. ENV FOO bar
  242. VOLUME \\\\\\\${FOO}
  243. `, true)
  244. if err != nil {
  245. t.Fatal(err)
  246. }
  247. res, err = inspectFieldJSON(name, "Config.Volumes")
  248. if err != nil {
  249. t.Fatal(err)
  250. }
  251. if err = unmarshalJSON([]byte(res), &result); err != nil {
  252. t.Fatal(err)
  253. }
  254. if _, ok := result[`\\\\\\${FOO}`]; !ok {
  255. t.Fatal(`Could not find volume \\\\\\${FOO} set from env foo in volumes table`)
  256. }
  257. logDone("build - handle escapes")
  258. }
  259. func TestBuildOnBuildLowercase(t *testing.T) {
  260. name := "testbuildonbuildlowercase"
  261. name2 := "testbuildonbuildlowercase2"
  262. defer deleteImages(name, name2)
  263. _, err := buildImage(name,
  264. `
  265. FROM busybox
  266. onbuild run echo quux
  267. `, true)
  268. if err != nil {
  269. t.Fatal(err)
  270. }
  271. _, out, err := buildImageWithOut(name2, fmt.Sprintf(`
  272. FROM %s
  273. `, name), true)
  274. if err != nil {
  275. t.Fatal(err)
  276. }
  277. if !strings.Contains(out, "quux") {
  278. t.Fatalf("Did not receive the expected echo text, got %s", out)
  279. }
  280. if strings.Contains(out, "ONBUILD ONBUILD") {
  281. t.Fatalf("Got an ONBUILD ONBUILD error with no error: got %s", out)
  282. }
  283. logDone("build - handle case-insensitive onbuild statement")
  284. }
  285. func TestBuildEnvEscapes(t *testing.T) {
  286. name := "testbuildenvescapes"
  287. defer deleteImages(name)
  288. defer deleteAllContainers()
  289. _, err := buildImage(name,
  290. `
  291. FROM busybox
  292. ENV TEST foo
  293. CMD echo \$
  294. `,
  295. true)
  296. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name))
  297. if err != nil {
  298. t.Fatal(err)
  299. }
  300. if strings.TrimSpace(out) != "$" {
  301. t.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))
  302. }
  303. logDone("build - env should handle \\$ properly")
  304. }
  305. func TestBuildEnvOverwrite(t *testing.T) {
  306. name := "testbuildenvoverwrite"
  307. defer deleteImages(name)
  308. defer deleteAllContainers()
  309. _, err := buildImage(name,
  310. `
  311. FROM busybox
  312. ENV TEST foo
  313. CMD echo ${TEST}
  314. `,
  315. true)
  316. if err != nil {
  317. t.Fatal(err)
  318. }
  319. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-e", "TEST=bar", "-t", name))
  320. if err != nil {
  321. t.Fatal(err)
  322. }
  323. if strings.TrimSpace(out) != "bar" {
  324. t.Fatalf("Env TEST was not overwritten with bar when foo was supplied to dockerfile: was %q", strings.TrimSpace(out))
  325. }
  326. logDone("build - env should overwrite builder ENV during run")
  327. }
  328. func TestBuildOnBuildForbiddenMaintainerInSourceImage(t *testing.T) {
  329. name := "testbuildonbuildforbiddenmaintainerinsourceimage"
  330. defer deleteImages("onbuild")
  331. defer deleteImages(name)
  332. defer deleteAllContainers()
  333. createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
  334. out, _, _, err := runCommandWithStdoutStderr(createCmd)
  335. if err != nil {
  336. t.Fatal(out, err)
  337. }
  338. cleanedContainerID := stripTrailingCharacters(out)
  339. commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"MAINTAINER docker.io\"]}", cleanedContainerID, "onbuild")
  340. if _, err := runCommand(commitCmd); err != nil {
  341. t.Fatal(err)
  342. }
  343. _, err = buildImage(name,
  344. `FROM onbuild`,
  345. true)
  346. if err != nil {
  347. if !strings.Contains(err.Error(), "maintainer isn't allowed as an ONBUILD trigger") {
  348. t.Fatalf("Wrong error %v, must be about MAINTAINER and ONBUILD in source image", err)
  349. }
  350. } else {
  351. t.Fatal("Error must not be nil")
  352. }
  353. logDone("build - onbuild forbidden maintainer in source image")
  354. }
  355. func TestBuildOnBuildForbiddenFromInSourceImage(t *testing.T) {
  356. name := "testbuildonbuildforbiddenfrominsourceimage"
  357. defer deleteImages("onbuild")
  358. defer deleteImages(name)
  359. defer deleteAllContainers()
  360. createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
  361. out, _, _, err := runCommandWithStdoutStderr(createCmd)
  362. if err != nil {
  363. t.Fatal(out, err)
  364. }
  365. cleanedContainerID := stripTrailingCharacters(out)
  366. commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"FROM busybox\"]}", cleanedContainerID, "onbuild")
  367. if _, err := runCommand(commitCmd); err != nil {
  368. t.Fatal(err)
  369. }
  370. _, err = buildImage(name,
  371. `FROM onbuild`,
  372. true)
  373. if err != nil {
  374. if !strings.Contains(err.Error(), "from isn't allowed as an ONBUILD trigger") {
  375. t.Fatalf("Wrong error %v, must be about FROM and ONBUILD in source image", err)
  376. }
  377. } else {
  378. t.Fatal("Error must not be nil")
  379. }
  380. logDone("build - onbuild forbidden from in source image")
  381. }
  382. func TestBuildOnBuildForbiddenChainedInSourceImage(t *testing.T) {
  383. name := "testbuildonbuildforbiddenchainedinsourceimage"
  384. defer deleteImages("onbuild")
  385. defer deleteImages(name)
  386. defer deleteAllContainers()
  387. createCmd := exec.Command(dockerBinary, "create", "busybox", "true")
  388. out, _, _, err := runCommandWithStdoutStderr(createCmd)
  389. if err != nil {
  390. t.Fatal(out, err)
  391. }
  392. cleanedContainerID := stripTrailingCharacters(out)
  393. commitCmd := exec.Command(dockerBinary, "commit", "--run", "{\"OnBuild\":[\"ONBUILD RUN ls\"]}", cleanedContainerID, "onbuild")
  394. if _, err := runCommand(commitCmd); err != nil {
  395. t.Fatal(err)
  396. }
  397. _, err = buildImage(name,
  398. `FROM onbuild`,
  399. true)
  400. if err != nil {
  401. if !strings.Contains(err.Error(), "Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") {
  402. t.Fatalf("Wrong error %v, must be about chaining ONBUILD in source image", err)
  403. }
  404. } else {
  405. t.Fatal("Error must not be nil")
  406. }
  407. logDone("build - onbuild forbidden chained in source image")
  408. }
  409. func TestBuildOnBuildCmdEntrypointJSON(t *testing.T) {
  410. name1 := "onbuildcmd"
  411. name2 := "onbuildgenerated"
  412. defer deleteImages(name2)
  413. defer deleteImages(name1)
  414. defer deleteAllContainers()
  415. _, err := buildImage(name1, `
  416. FROM busybox
  417. ONBUILD CMD ["hello world"]
  418. ONBUILD ENTRYPOINT ["echo"]
  419. ONBUILD RUN ["true"]`,
  420. false)
  421. if err != nil {
  422. t.Fatal(err)
  423. }
  424. _, err = buildImage(name2, fmt.Sprintf(`FROM %s`, name1), false)
  425. if err != nil {
  426. t.Fatal(err)
  427. }
  428. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name2))
  429. if err != nil {
  430. t.Fatal(err)
  431. }
  432. if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {
  433. t.Fatal("did not get echo output from onbuild", out)
  434. }
  435. logDone("build - onbuild with json entrypoint/cmd")
  436. }
  437. func TestBuildOnBuildEntrypointJSON(t *testing.T) {
  438. name1 := "onbuildcmd"
  439. name2 := "onbuildgenerated"
  440. defer deleteImages(name2)
  441. defer deleteImages(name1)
  442. defer deleteAllContainers()
  443. _, err := buildImage(name1, `
  444. FROM busybox
  445. ONBUILD ENTRYPOINT ["echo"]`,
  446. false)
  447. if err != nil {
  448. t.Fatal(err)
  449. }
  450. _, err = buildImage(name2, fmt.Sprintf("FROM %s\nCMD [\"hello world\"]\n", name1), false)
  451. if err != nil {
  452. t.Fatal(err)
  453. }
  454. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name2))
  455. if err != nil {
  456. t.Fatal(err)
  457. }
  458. if !regexp.MustCompile(`(?m)^hello world`).MatchString(out) {
  459. t.Fatal("got malformed output from onbuild", out)
  460. }
  461. logDone("build - onbuild with json entrypoint")
  462. }
  463. func TestBuildCacheADD(t *testing.T) {
  464. name := "testbuildtwoimageswithadd"
  465. defer deleteImages(name)
  466. server, err := fakeStorage(map[string]string{
  467. "robots.txt": "hello",
  468. "index.html": "world",
  469. })
  470. if err != nil {
  471. t.Fatal(err)
  472. }
  473. defer server.Close()
  474. if _, err := buildImage(name,
  475. fmt.Sprintf(`FROM scratch
  476. ADD %s/robots.txt /`, server.URL),
  477. true); err != nil {
  478. t.Fatal(err)
  479. }
  480. if err != nil {
  481. t.Fatal(err)
  482. }
  483. deleteImages(name)
  484. _, out, err := buildImageWithOut(name,
  485. fmt.Sprintf(`FROM scratch
  486. ADD %s/index.html /`, server.URL),
  487. true)
  488. if err != nil {
  489. t.Fatal(err)
  490. }
  491. if strings.Contains(out, "Using cache") {
  492. t.Fatal("2nd build used cache on ADD, it shouldn't")
  493. }
  494. logDone("build - build two images with remote ADD")
  495. }
  496. func TestBuildSixtySteps(t *testing.T) {
  497. name := "foobuildsixtysteps"
  498. defer deleteImages(name)
  499. ctx, err := fakeContext("FROM scratch\n"+strings.Repeat("ADD foo /\n", 60),
  500. map[string]string{
  501. "foo": "test1",
  502. })
  503. if err != nil {
  504. t.Fatal(err)
  505. }
  506. defer ctx.Close()
  507. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  508. t.Fatal(err)
  509. }
  510. logDone("build - build an image with sixty build steps")
  511. }
  512. func TestBuildAddSingleFileToRoot(t *testing.T) {
  513. name := "testaddimg"
  514. defer deleteImages(name)
  515. ctx, err := fakeContext(`FROM busybox
  516. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  517. RUN echo 'dockerio:x:1001:' >> /etc/group
  518. RUN touch /exists
  519. RUN chown dockerio.dockerio /exists
  520. ADD test_file /
  521. RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]
  522. RUN [ $(ls -l /test_file | awk '{print $1}') = '-rw-r--r--' ]
  523. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  524. map[string]string{
  525. "test_file": "test1",
  526. })
  527. if err != nil {
  528. t.Fatal(err)
  529. }
  530. defer ctx.Close()
  531. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  532. t.Fatal(err)
  533. }
  534. logDone("build - add single file to root")
  535. }
  536. // Issue #3960: "ADD src ." hangs
  537. func TestBuildAddSingleFileToWorkdir(t *testing.T) {
  538. name := "testaddsinglefiletoworkdir"
  539. defer deleteImages(name)
  540. ctx, err := fakeContext(`FROM busybox
  541. ADD test_file .`,
  542. map[string]string{
  543. "test_file": "test1",
  544. })
  545. if err != nil {
  546. t.Fatal(err)
  547. }
  548. defer ctx.Close()
  549. done := make(chan struct{})
  550. go func() {
  551. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  552. t.Fatal(err)
  553. }
  554. close(done)
  555. }()
  556. select {
  557. case <-time.After(5 * time.Second):
  558. t.Fatal("Build with adding to workdir timed out")
  559. case <-done:
  560. }
  561. logDone("build - add single file to workdir")
  562. }
  563. func TestBuildAddSingleFileToExistDir(t *testing.T) {
  564. name := "testaddsinglefiletoexistdir"
  565. defer deleteImages(name)
  566. ctx, err := fakeContext(`FROM busybox
  567. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  568. RUN echo 'dockerio:x:1001:' >> /etc/group
  569. RUN mkdir /exists
  570. RUN touch /exists/exists_file
  571. RUN chown -R dockerio.dockerio /exists
  572. ADD test_file /exists/
  573. RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  574. RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]
  575. RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  576. map[string]string{
  577. "test_file": "test1",
  578. })
  579. if err != nil {
  580. t.Fatal(err)
  581. }
  582. defer ctx.Close()
  583. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  584. t.Fatal(err)
  585. }
  586. logDone("build - add single file to existing dir")
  587. }
  588. func TestBuildCopyAddMultipleFiles(t *testing.T) {
  589. name := "testcopymultiplefilestofile"
  590. defer deleteImages(name)
  591. ctx, err := fakeContext(`FROM busybox
  592. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  593. RUN echo 'dockerio:x:1001:' >> /etc/group
  594. RUN mkdir /exists
  595. RUN touch /exists/exists_file
  596. RUN chown -R dockerio.dockerio /exists
  597. COPY test_file1 test_file2 /exists/
  598. ADD test_file3 test_file4 https://docker.com/robots.txt /exists/
  599. RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  600. RUN [ $(ls -l /exists/test_file1 | awk '{print $3":"$4}') = 'root:root' ]
  601. RUN [ $(ls -l /exists/test_file2 | awk '{print $3":"$4}') = 'root:root' ]
  602. RUN [ $(ls -l /exists/test_file3 | awk '{print $3":"$4}') = 'root:root' ]
  603. RUN [ $(ls -l /exists/test_file4 | awk '{print $3":"$4}') = 'root:root' ]
  604. RUN [ $(ls -l /exists/robots.txt | awk '{print $3":"$4}') = 'root:root' ]
  605. RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  606. `,
  607. map[string]string{
  608. "test_file1": "test1",
  609. "test_file2": "test2",
  610. "test_file3": "test3",
  611. "test_file4": "test4",
  612. })
  613. defer ctx.Close()
  614. if err != nil {
  615. t.Fatal(err)
  616. }
  617. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  618. t.Fatal(err)
  619. }
  620. logDone("build - mulitple file copy/add tests")
  621. }
  622. func TestBuildAddMultipleFilesToFile(t *testing.T) {
  623. name := "testaddmultiplefilestofile"
  624. defer deleteImages(name)
  625. ctx, err := fakeContext(`FROM scratch
  626. ADD file1.txt file2.txt test
  627. `,
  628. map[string]string{
  629. "file1.txt": "test1",
  630. "file2.txt": "test1",
  631. })
  632. defer ctx.Close()
  633. if err != nil {
  634. t.Fatal(err)
  635. }
  636. expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
  637. if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {
  638. t.Fatalf("Wrong error: (should contain \"%s\") got:\n%v", expected, err)
  639. }
  640. logDone("build - multiple add files to file")
  641. }
  642. func TestBuildAddMultipleFilesToFileWild(t *testing.T) {
  643. name := "testaddmultiplefilestofilewild"
  644. defer deleteImages(name)
  645. ctx, err := fakeContext(`FROM scratch
  646. ADD file*.txt test
  647. `,
  648. map[string]string{
  649. "file1.txt": "test1",
  650. "file2.txt": "test1",
  651. })
  652. defer ctx.Close()
  653. if err != nil {
  654. t.Fatal(err)
  655. }
  656. expected := "When using ADD with more than one source file, the destination must be a directory and end with a /"
  657. if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {
  658. t.Fatalf("Wrong error: (should contain \"%s\") got:\n%v", expected, err)
  659. }
  660. logDone("build - multiple add files to file wild")
  661. }
  662. func TestBuildCopyMultipleFilesToFile(t *testing.T) {
  663. name := "testcopymultiplefilestofile"
  664. defer deleteImages(name)
  665. ctx, err := fakeContext(`FROM scratch
  666. COPY file1.txt file2.txt test
  667. `,
  668. map[string]string{
  669. "file1.txt": "test1",
  670. "file2.txt": "test1",
  671. })
  672. defer ctx.Close()
  673. if err != nil {
  674. t.Fatal(err)
  675. }
  676. expected := "When using COPY with more than one source file, the destination must be a directory and end with a /"
  677. if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {
  678. t.Fatalf("Wrong error: (should contain \"%s\") got:\n%v", expected, err)
  679. }
  680. logDone("build - multiple copy files to file")
  681. }
  682. func TestBuildCopyWildcard(t *testing.T) {
  683. name := "testcopywildcard"
  684. defer deleteImages(name)
  685. server, err := fakeStorage(map[string]string{
  686. "robots.txt": "hello",
  687. "index.html": "world",
  688. })
  689. if err != nil {
  690. t.Fatal(err)
  691. }
  692. defer server.Close()
  693. ctx, err := fakeContext(fmt.Sprintf(`FROM busybox
  694. COPY file*.txt /tmp/
  695. RUN ls /tmp/file1.txt /tmp/file2.txt
  696. RUN mkdir /tmp1
  697. COPY dir* /tmp1/
  698. RUN ls /tmp1/dirt /tmp1/nested_file /tmp1/nested_dir/nest_nest_file
  699. RUN mkdir /tmp2
  700. ADD dir/*dir %s/robots.txt /tmp2/
  701. RUN ls /tmp2/nest_nest_file /tmp2/robots.txt
  702. `, server.URL),
  703. map[string]string{
  704. "file1.txt": "test1",
  705. "file2.txt": "test2",
  706. "dir/nested_file": "nested file",
  707. "dir/nested_dir/nest_nest_file": "2 times nested",
  708. "dirt": "dirty",
  709. })
  710. defer ctx.Close()
  711. if err != nil {
  712. t.Fatal(err)
  713. }
  714. id1, err := buildImageFromContext(name, ctx, true)
  715. if err != nil {
  716. t.Fatal(err)
  717. }
  718. // Now make sure we use a cache the 2nd time
  719. id2, err := buildImageFromContext(name, ctx, true)
  720. if err != nil {
  721. t.Fatal(err)
  722. }
  723. if id1 != id2 {
  724. t.Fatal("didn't use the cache")
  725. }
  726. logDone("build - copy wild card")
  727. }
  728. func TestBuildCopyWildcardNoFind(t *testing.T) {
  729. name := "testcopywildcardnofind"
  730. defer deleteImages(name)
  731. ctx, err := fakeContext(`FROM busybox
  732. COPY file*.txt /tmp/
  733. `, nil)
  734. defer ctx.Close()
  735. if err != nil {
  736. t.Fatal(err)
  737. }
  738. _, err = buildImageFromContext(name, ctx, true)
  739. if err == nil {
  740. t.Fatal("should have failed to find a file")
  741. }
  742. if !strings.Contains(err.Error(), "No source files were specified") {
  743. t.Fatalf("Wrong error %v, must be about no source files", err)
  744. }
  745. logDone("build - copy wild card no find")
  746. }
  747. func TestBuildCopyWildcardCache(t *testing.T) {
  748. name := "testcopywildcardcache"
  749. defer deleteImages(name)
  750. ctx, err := fakeContext(`FROM busybox
  751. COPY file1.txt /tmp/`,
  752. map[string]string{
  753. "file1.txt": "test1",
  754. })
  755. defer ctx.Close()
  756. if err != nil {
  757. t.Fatal(err)
  758. }
  759. id1, err := buildImageFromContext(name, ctx, true)
  760. if err != nil {
  761. t.Fatal(err)
  762. }
  763. // Now make sure we use a cache the 2nd time even with wild cards.
  764. // Use the same context so the file is the same and the checksum will match
  765. ctx.Add("Dockerfile", `FROM busybox
  766. COPY file*.txt /tmp/`)
  767. id2, err := buildImageFromContext(name, ctx, true)
  768. if err != nil {
  769. t.Fatal(err)
  770. }
  771. if id1 != id2 {
  772. t.Fatal("didn't use the cache")
  773. }
  774. logDone("build - copy wild card cache")
  775. }
  776. func TestBuildAddSingleFileToNonExistingDir(t *testing.T) {
  777. name := "testaddsinglefiletononexistingdir"
  778. defer deleteImages(name)
  779. ctx, err := fakeContext(`FROM busybox
  780. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  781. RUN echo 'dockerio:x:1001:' >> /etc/group
  782. RUN touch /exists
  783. RUN chown dockerio.dockerio /exists
  784. ADD test_file /test_dir/
  785. RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
  786. RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]
  787. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  788. map[string]string{
  789. "test_file": "test1",
  790. })
  791. if err != nil {
  792. t.Fatal(err)
  793. }
  794. defer ctx.Close()
  795. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  796. t.Fatal(err)
  797. }
  798. logDone("build - add single file to non-existing dir")
  799. }
  800. func TestBuildAddDirContentToRoot(t *testing.T) {
  801. name := "testadddircontenttoroot"
  802. defer deleteImages(name)
  803. ctx, err := fakeContext(`FROM busybox
  804. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  805. RUN echo 'dockerio:x:1001:' >> /etc/group
  806. RUN touch /exists
  807. RUN chown dockerio.dockerio exists
  808. ADD test_dir /
  809. RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]
  810. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  811. map[string]string{
  812. "test_dir/test_file": "test1",
  813. })
  814. if err != nil {
  815. t.Fatal(err)
  816. }
  817. defer ctx.Close()
  818. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  819. t.Fatal(err)
  820. }
  821. logDone("build - add directory contents to root")
  822. }
  823. func TestBuildAddDirContentToExistingDir(t *testing.T) {
  824. name := "testadddircontenttoexistingdir"
  825. defer deleteImages(name)
  826. ctx, err := fakeContext(`FROM busybox
  827. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  828. RUN echo 'dockerio:x:1001:' >> /etc/group
  829. RUN mkdir /exists
  830. RUN touch /exists/exists_file
  831. RUN chown -R dockerio.dockerio /exists
  832. ADD test_dir/ /exists/
  833. RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  834. RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  835. RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]`,
  836. map[string]string{
  837. "test_dir/test_file": "test1",
  838. })
  839. if err != nil {
  840. t.Fatal(err)
  841. }
  842. defer ctx.Close()
  843. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  844. t.Fatal(err)
  845. }
  846. logDone("build - add directory contents to existing dir")
  847. }
  848. func TestBuildAddWholeDirToRoot(t *testing.T) {
  849. name := "testaddwholedirtoroot"
  850. defer deleteImages(name)
  851. ctx, err := fakeContext(`FROM busybox
  852. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  853. RUN echo 'dockerio:x:1001:' >> /etc/group
  854. RUN touch /exists
  855. RUN chown dockerio.dockerio exists
  856. ADD test_dir /test_dir
  857. RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
  858. RUN [ $(ls -l / | grep test_dir | awk '{print $1}') = 'drwxr-xr-x' ]
  859. RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]
  860. RUN [ $(ls -l /test_dir/test_file | awk '{print $1}') = '-rw-r--r--' ]
  861. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  862. map[string]string{
  863. "test_dir/test_file": "test1",
  864. })
  865. if err != nil {
  866. t.Fatal(err)
  867. }
  868. defer ctx.Close()
  869. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  870. t.Fatal(err)
  871. }
  872. logDone("build - add whole directory to root")
  873. }
  874. // Testing #5941
  875. func TestBuildAddEtcToRoot(t *testing.T) {
  876. name := "testaddetctoroot"
  877. defer deleteImages(name)
  878. ctx, err := fakeContext(`FROM scratch
  879. ADD . /`,
  880. map[string]string{
  881. "etc/test_file": "test1",
  882. })
  883. if err != nil {
  884. t.Fatal(err)
  885. }
  886. defer ctx.Close()
  887. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  888. t.Fatal(err)
  889. }
  890. logDone("build - add etc directory to root")
  891. }
  892. // Testing #9401
  893. func TestBuildAddPreservesFilesSpecialBits(t *testing.T) {
  894. name := "testaddpreservesfilesspecialbits"
  895. defer deleteImages(name)
  896. ctx, err := fakeContext(`FROM busybox
  897. ADD suidbin /usr/bin/suidbin
  898. RUN chmod 4755 /usr/bin/suidbin
  899. RUN [ $(ls -l /usr/bin/suidbin | awk '{print $1}') = '-rwsr-xr-x' ]
  900. ADD ./data/ /
  901. RUN [ $(ls -l /usr/bin/suidbin | awk '{print $1}') = '-rwsr-xr-x' ]`,
  902. map[string]string{
  903. "suidbin": "suidbin",
  904. "/data/usr/test_file": "test1",
  905. })
  906. if err != nil {
  907. t.Fatal(err)
  908. }
  909. defer ctx.Close()
  910. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  911. t.Fatal(err)
  912. }
  913. logDone("build - add preserves files special bits")
  914. }
  915. func TestBuildCopySingleFileToRoot(t *testing.T) {
  916. name := "testcopysinglefiletoroot"
  917. defer deleteImages(name)
  918. ctx, err := fakeContext(`FROM busybox
  919. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  920. RUN echo 'dockerio:x:1001:' >> /etc/group
  921. RUN touch /exists
  922. RUN chown dockerio.dockerio /exists
  923. COPY test_file /
  924. RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]
  925. RUN [ $(ls -l /test_file | awk '{print $1}') = '-rw-r--r--' ]
  926. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  927. map[string]string{
  928. "test_file": "test1",
  929. })
  930. if err != nil {
  931. t.Fatal(err)
  932. }
  933. defer ctx.Close()
  934. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  935. t.Fatal(err)
  936. }
  937. logDone("build - copy single file to root")
  938. }
  939. // Issue #3960: "ADD src ." hangs - adapted for COPY
  940. func TestBuildCopySingleFileToWorkdir(t *testing.T) {
  941. name := "testcopysinglefiletoworkdir"
  942. defer deleteImages(name)
  943. ctx, err := fakeContext(`FROM busybox
  944. COPY test_file .`,
  945. map[string]string{
  946. "test_file": "test1",
  947. })
  948. if err != nil {
  949. t.Fatal(err)
  950. }
  951. defer ctx.Close()
  952. done := make(chan struct{})
  953. go func() {
  954. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  955. t.Fatal(err)
  956. }
  957. close(done)
  958. }()
  959. select {
  960. case <-time.After(5 * time.Second):
  961. t.Fatal("Build with adding to workdir timed out")
  962. case <-done:
  963. }
  964. logDone("build - copy single file to workdir")
  965. }
  966. func TestBuildCopySingleFileToExistDir(t *testing.T) {
  967. name := "testcopysinglefiletoexistdir"
  968. defer deleteImages(name)
  969. ctx, err := fakeContext(`FROM busybox
  970. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  971. RUN echo 'dockerio:x:1001:' >> /etc/group
  972. RUN mkdir /exists
  973. RUN touch /exists/exists_file
  974. RUN chown -R dockerio.dockerio /exists
  975. COPY test_file /exists/
  976. RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  977. RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]
  978. RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  979. map[string]string{
  980. "test_file": "test1",
  981. })
  982. if err != nil {
  983. t.Fatal(err)
  984. }
  985. defer ctx.Close()
  986. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  987. t.Fatal(err)
  988. }
  989. logDone("build - copy single file to existing dir")
  990. }
  991. func TestBuildCopySingleFileToNonExistDir(t *testing.T) {
  992. name := "testcopysinglefiletononexistdir"
  993. defer deleteImages(name)
  994. ctx, err := fakeContext(`FROM busybox
  995. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  996. RUN echo 'dockerio:x:1001:' >> /etc/group
  997. RUN touch /exists
  998. RUN chown dockerio.dockerio /exists
  999. COPY test_file /test_dir/
  1000. RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
  1001. RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]
  1002. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  1003. map[string]string{
  1004. "test_file": "test1",
  1005. })
  1006. if err != nil {
  1007. t.Fatal(err)
  1008. }
  1009. defer ctx.Close()
  1010. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1011. t.Fatal(err)
  1012. }
  1013. logDone("build - copy single file to non-existing dir")
  1014. }
  1015. func TestBuildCopyDirContentToRoot(t *testing.T) {
  1016. name := "testcopydircontenttoroot"
  1017. defer deleteImages(name)
  1018. ctx, err := fakeContext(`FROM busybox
  1019. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  1020. RUN echo 'dockerio:x:1001:' >> /etc/group
  1021. RUN touch /exists
  1022. RUN chown dockerio.dockerio exists
  1023. COPY test_dir /
  1024. RUN [ $(ls -l /test_file | awk '{print $3":"$4}') = 'root:root' ]
  1025. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  1026. map[string]string{
  1027. "test_dir/test_file": "test1",
  1028. })
  1029. if err != nil {
  1030. t.Fatal(err)
  1031. }
  1032. defer ctx.Close()
  1033. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1034. t.Fatal(err)
  1035. }
  1036. logDone("build - copy directory contents to root")
  1037. }
  1038. func TestBuildCopyDirContentToExistDir(t *testing.T) {
  1039. name := "testcopydircontenttoexistdir"
  1040. defer deleteImages(name)
  1041. ctx, err := fakeContext(`FROM busybox
  1042. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  1043. RUN echo 'dockerio:x:1001:' >> /etc/group
  1044. RUN mkdir /exists
  1045. RUN touch /exists/exists_file
  1046. RUN chown -R dockerio.dockerio /exists
  1047. COPY test_dir/ /exists/
  1048. RUN [ $(ls -l / | grep exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  1049. RUN [ $(ls -l /exists/exists_file | awk '{print $3":"$4}') = 'dockerio:dockerio' ]
  1050. RUN [ $(ls -l /exists/test_file | awk '{print $3":"$4}') = 'root:root' ]`,
  1051. map[string]string{
  1052. "test_dir/test_file": "test1",
  1053. })
  1054. if err != nil {
  1055. t.Fatal(err)
  1056. }
  1057. defer ctx.Close()
  1058. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1059. t.Fatal(err)
  1060. }
  1061. logDone("build - copy directory contents to existing dir")
  1062. }
  1063. func TestBuildCopyWholeDirToRoot(t *testing.T) {
  1064. name := "testcopywholedirtoroot"
  1065. defer deleteImages(name)
  1066. ctx, err := fakeContext(`FROM busybox
  1067. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  1068. RUN echo 'dockerio:x:1001:' >> /etc/group
  1069. RUN touch /exists
  1070. RUN chown dockerio.dockerio exists
  1071. COPY test_dir /test_dir
  1072. RUN [ $(ls -l / | grep test_dir | awk '{print $3":"$4}') = 'root:root' ]
  1073. RUN [ $(ls -l / | grep test_dir | awk '{print $1}') = 'drwxr-xr-x' ]
  1074. RUN [ $(ls -l /test_dir/test_file | awk '{print $3":"$4}') = 'root:root' ]
  1075. RUN [ $(ls -l /test_dir/test_file | awk '{print $1}') = '-rw-r--r--' ]
  1076. RUN [ $(ls -l /exists | awk '{print $3":"$4}') = 'dockerio:dockerio' ]`,
  1077. map[string]string{
  1078. "test_dir/test_file": "test1",
  1079. })
  1080. if err != nil {
  1081. t.Fatal(err)
  1082. }
  1083. defer ctx.Close()
  1084. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1085. t.Fatal(err)
  1086. }
  1087. logDone("build - copy whole directory to root")
  1088. }
  1089. func TestBuildCopyEtcToRoot(t *testing.T) {
  1090. name := "testcopyetctoroot"
  1091. defer deleteImages(name)
  1092. ctx, err := fakeContext(`FROM scratch
  1093. COPY . /`,
  1094. map[string]string{
  1095. "etc/test_file": "test1",
  1096. })
  1097. if err != nil {
  1098. t.Fatal(err)
  1099. }
  1100. defer ctx.Close()
  1101. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1102. t.Fatal(err)
  1103. }
  1104. logDone("build - copy etc directory to root")
  1105. }
  1106. func TestBuildCopyDisallowRemote(t *testing.T) {
  1107. name := "testcopydisallowremote"
  1108. defer deleteImages(name)
  1109. _, out, err := buildImageWithOut(name, `FROM scratch
  1110. COPY https://index.docker.io/robots.txt /`,
  1111. true)
  1112. if err == nil || !strings.Contains(out, "Source can't be a URL for COPY") {
  1113. t.Fatalf("Error should be about disallowed remote source, got err: %s, out: %q", err, out)
  1114. }
  1115. logDone("build - copy - disallow copy from remote")
  1116. }
  1117. func TestBuildAddBadLinks(t *testing.T) {
  1118. const (
  1119. dockerfile = `
  1120. FROM scratch
  1121. ADD links.tar /
  1122. ADD foo.txt /symlink/
  1123. `
  1124. targetFile = "foo.txt"
  1125. )
  1126. var (
  1127. name = "test-link-absolute"
  1128. )
  1129. defer deleteImages(name)
  1130. ctx, err := fakeContext(dockerfile, nil)
  1131. if err != nil {
  1132. t.Fatal(err)
  1133. }
  1134. defer ctx.Close()
  1135. tempDir, err := ioutil.TempDir("", "test-link-absolute-temp-")
  1136. if err != nil {
  1137. t.Fatalf("failed to create temporary directory: %s", tempDir)
  1138. }
  1139. defer os.RemoveAll(tempDir)
  1140. symlinkTarget := fmt.Sprintf("/../../../../../../../../../../../..%s", tempDir)
  1141. tarPath := filepath.Join(ctx.Dir, "links.tar")
  1142. nonExistingFile := filepath.Join(tempDir, targetFile)
  1143. fooPath := filepath.Join(ctx.Dir, targetFile)
  1144. tarOut, err := os.Create(tarPath)
  1145. if err != nil {
  1146. t.Fatal(err)
  1147. }
  1148. tarWriter := tar.NewWriter(tarOut)
  1149. header := &tar.Header{
  1150. Name: "symlink",
  1151. Typeflag: tar.TypeSymlink,
  1152. Linkname: symlinkTarget,
  1153. Mode: 0755,
  1154. Uid: 0,
  1155. Gid: 0,
  1156. }
  1157. err = tarWriter.WriteHeader(header)
  1158. if err != nil {
  1159. t.Fatal(err)
  1160. }
  1161. tarWriter.Close()
  1162. tarOut.Close()
  1163. foo, err := os.Create(fooPath)
  1164. if err != nil {
  1165. t.Fatal(err)
  1166. }
  1167. defer foo.Close()
  1168. if _, err := foo.WriteString("test"); err != nil {
  1169. t.Fatal(err)
  1170. }
  1171. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1172. t.Fatal(err)
  1173. }
  1174. if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {
  1175. t.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)
  1176. }
  1177. logDone("build - ADD must add files in container")
  1178. }
  1179. func TestBuildAddBadLinksVolume(t *testing.T) {
  1180. const (
  1181. dockerfileTemplate = `
  1182. FROM busybox
  1183. RUN ln -s /../../../../../../../../%s /x
  1184. VOLUME /x
  1185. ADD foo.txt /x/`
  1186. targetFile = "foo.txt"
  1187. )
  1188. var (
  1189. name = "test-link-absolute-volume"
  1190. dockerfile = ""
  1191. )
  1192. defer deleteImages(name)
  1193. tempDir, err := ioutil.TempDir("", "test-link-absolute-volume-temp-")
  1194. if err != nil {
  1195. t.Fatalf("failed to create temporary directory: %s", tempDir)
  1196. }
  1197. defer os.RemoveAll(tempDir)
  1198. dockerfile = fmt.Sprintf(dockerfileTemplate, tempDir)
  1199. nonExistingFile := filepath.Join(tempDir, targetFile)
  1200. ctx, err := fakeContext(dockerfile, nil)
  1201. if err != nil {
  1202. t.Fatal(err)
  1203. }
  1204. defer ctx.Close()
  1205. fooPath := filepath.Join(ctx.Dir, targetFile)
  1206. foo, err := os.Create(fooPath)
  1207. if err != nil {
  1208. t.Fatal(err)
  1209. }
  1210. defer foo.Close()
  1211. if _, err := foo.WriteString("test"); err != nil {
  1212. t.Fatal(err)
  1213. }
  1214. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1215. t.Fatal(err)
  1216. }
  1217. if _, err := os.Stat(nonExistingFile); err == nil || err != nil && !os.IsNotExist(err) {
  1218. t.Fatalf("%s shouldn't have been written and it shouldn't exist", nonExistingFile)
  1219. }
  1220. logDone("build - ADD should add files in volume")
  1221. }
  1222. // Issue #5270 - ensure we throw a better error than "unexpected EOF"
  1223. // when we can't access files in the context.
  1224. func TestBuildWithInaccessibleFilesInContext(t *testing.T) {
  1225. {
  1226. name := "testbuildinaccessiblefiles"
  1227. defer deleteImages(name)
  1228. ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"fileWithoutReadAccess": "foo"})
  1229. if err != nil {
  1230. t.Fatal(err)
  1231. }
  1232. defer ctx.Close()
  1233. // This is used to ensure we detect inaccessible files early during build in the cli client
  1234. pathToFileWithoutReadAccess := filepath.Join(ctx.Dir, "fileWithoutReadAccess")
  1235. if err = os.Chown(pathToFileWithoutReadAccess, 0, 0); err != nil {
  1236. t.Fatalf("failed to chown file to root: %s", err)
  1237. }
  1238. if err = os.Chmod(pathToFileWithoutReadAccess, 0700); err != nil {
  1239. t.Fatalf("failed to chmod file to 700: %s", err)
  1240. }
  1241. buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
  1242. buildCmd.Dir = ctx.Dir
  1243. out, _, err := runCommandWithOutput(buildCmd)
  1244. if err == nil {
  1245. t.Fatalf("build should have failed: %s %s", err, out)
  1246. }
  1247. // check if we've detected the failure before we started building
  1248. if !strings.Contains(out, "no permission to read from ") {
  1249. t.Fatalf("output should've contained the string: no permission to read from but contained: %s", out)
  1250. }
  1251. if !strings.Contains(out, "Error checking context is accessible") {
  1252. t.Fatalf("output should've contained the string: Error checking context is accessible")
  1253. }
  1254. }
  1255. {
  1256. name := "testbuildinaccessibledirectory"
  1257. defer deleteImages(name)
  1258. ctx, err := fakeContext("FROM scratch\nADD . /foo/", map[string]string{"directoryWeCantStat/bar": "foo"})
  1259. if err != nil {
  1260. t.Fatal(err)
  1261. }
  1262. defer ctx.Close()
  1263. // This is used to ensure we detect inaccessible directories early during build in the cli client
  1264. pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")
  1265. pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")
  1266. if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {
  1267. t.Fatalf("failed to chown directory to root: %s", err)
  1268. }
  1269. if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {
  1270. t.Fatalf("failed to chmod directory to 755: %s", err)
  1271. }
  1272. if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {
  1273. t.Fatalf("failed to chmod file to 444: %s", err)
  1274. }
  1275. buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
  1276. buildCmd.Dir = ctx.Dir
  1277. out, _, err := runCommandWithOutput(buildCmd)
  1278. if err == nil {
  1279. t.Fatalf("build should have failed: %s %s", err, out)
  1280. }
  1281. // check if we've detected the failure before we started building
  1282. if !strings.Contains(out, "can't stat") {
  1283. t.Fatalf("output should've contained the string: can't access %s", out)
  1284. }
  1285. if !strings.Contains(out, "Error checking context is accessible") {
  1286. t.Fatalf("output should've contained the string: Error checking context is accessible")
  1287. }
  1288. }
  1289. {
  1290. name := "testlinksok"
  1291. defer deleteImages(name)
  1292. ctx, err := fakeContext("FROM scratch\nADD . /foo/", nil)
  1293. if err != nil {
  1294. t.Fatal(err)
  1295. }
  1296. defer ctx.Close()
  1297. target := "../../../../../../../../../../../../../../../../../../../azA"
  1298. if err := os.Symlink(filepath.Join(ctx.Dir, "g"), target); err != nil {
  1299. t.Fatal(err)
  1300. }
  1301. defer os.Remove(target)
  1302. // This is used to ensure we don't follow links when checking if everything in the context is accessible
  1303. // This test doesn't require that we run commands as an unprivileged user
  1304. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  1305. t.Fatal(err)
  1306. }
  1307. }
  1308. {
  1309. name := "testbuildignoredinaccessible"
  1310. defer deleteImages(name)
  1311. ctx, err := fakeContext("FROM scratch\nADD . /foo/",
  1312. map[string]string{
  1313. "directoryWeCantStat/bar": "foo",
  1314. ".dockerignore": "directoryWeCantStat",
  1315. })
  1316. if err != nil {
  1317. t.Fatal(err)
  1318. }
  1319. defer ctx.Close()
  1320. // This is used to ensure we don't try to add inaccessible files when they are ignored by a .dockerignore pattern
  1321. pathToDirectoryWithoutReadAccess := filepath.Join(ctx.Dir, "directoryWeCantStat")
  1322. pathToFileInDirectoryWithoutReadAccess := filepath.Join(pathToDirectoryWithoutReadAccess, "bar")
  1323. if err = os.Chown(pathToDirectoryWithoutReadAccess, 0, 0); err != nil {
  1324. t.Fatalf("failed to chown directory to root: %s", err)
  1325. }
  1326. if err = os.Chmod(pathToDirectoryWithoutReadAccess, 0444); err != nil {
  1327. t.Fatalf("failed to chmod directory to 755: %s", err)
  1328. }
  1329. if err = os.Chmod(pathToFileInDirectoryWithoutReadAccess, 0700); err != nil {
  1330. t.Fatalf("failed to chmod file to 444: %s", err)
  1331. }
  1332. buildCmd := exec.Command("su", "unprivilegeduser", "-c", fmt.Sprintf("%s build -t %s .", dockerBinary, name))
  1333. buildCmd.Dir = ctx.Dir
  1334. if out, _, err := runCommandWithOutput(buildCmd); err != nil {
  1335. t.Fatalf("build should have worked: %s %s", err, out)
  1336. }
  1337. }
  1338. logDone("build - ADD from context with inaccessible files must fail")
  1339. logDone("build - ADD from context with accessible links must work")
  1340. logDone("build - ADD from context with ignored inaccessible files must work")
  1341. }
  1342. func TestBuildForceRm(t *testing.T) {
  1343. containerCountBefore, err := getContainerCount()
  1344. if err != nil {
  1345. t.Fatalf("failed to get the container count: %s", err)
  1346. }
  1347. name := "testbuildforcerm"
  1348. defer deleteImages(name)
  1349. ctx, err := fakeContext("FROM scratch\nRUN true\nRUN thiswillfail", nil)
  1350. if err != nil {
  1351. t.Fatal(err)
  1352. }
  1353. defer ctx.Close()
  1354. buildCmd := exec.Command(dockerBinary, "build", "-t", name, "--force-rm", ".")
  1355. buildCmd.Dir = ctx.Dir
  1356. if out, _, err := runCommandWithOutput(buildCmd); err == nil {
  1357. t.Fatalf("failed to build the image: %s, %v", out, err)
  1358. }
  1359. containerCountAfter, err := getContainerCount()
  1360. if err != nil {
  1361. t.Fatalf("failed to get the container count: %s", err)
  1362. }
  1363. if containerCountBefore != containerCountAfter {
  1364. t.Fatalf("--force-rm shouldn't have left containers behind")
  1365. }
  1366. logDone("build - ensure --force-rm doesn't leave containers behind")
  1367. }
  1368. func TestBuildRm(t *testing.T) {
  1369. name := "testbuildrm"
  1370. defer deleteImages(name)
  1371. ctx, err := fakeContext("FROM scratch\nADD foo /\nADD foo /", map[string]string{"foo": "bar"})
  1372. if err != nil {
  1373. t.Fatal(err)
  1374. }
  1375. defer ctx.Close()
  1376. {
  1377. containerCountBefore, err := getContainerCount()
  1378. if err != nil {
  1379. t.Fatalf("failed to get the container count: %s", err)
  1380. }
  1381. out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm", "-t", name, ".")
  1382. if err != nil {
  1383. t.Fatal("failed to build the image", out)
  1384. }
  1385. containerCountAfter, err := getContainerCount()
  1386. if err != nil {
  1387. t.Fatalf("failed to get the container count: %s", err)
  1388. }
  1389. if containerCountBefore != containerCountAfter {
  1390. t.Fatalf("-rm shouldn't have left containers behind")
  1391. }
  1392. deleteImages(name)
  1393. }
  1394. {
  1395. containerCountBefore, err := getContainerCount()
  1396. if err != nil {
  1397. t.Fatalf("failed to get the container count: %s", err)
  1398. }
  1399. out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "-t", name, ".")
  1400. if err != nil {
  1401. t.Fatal("failed to build the image", out)
  1402. }
  1403. containerCountAfter, err := getContainerCount()
  1404. if err != nil {
  1405. t.Fatalf("failed to get the container count: %s", err)
  1406. }
  1407. if containerCountBefore != containerCountAfter {
  1408. t.Fatalf("--rm shouldn't have left containers behind")
  1409. }
  1410. deleteImages(name)
  1411. }
  1412. {
  1413. containerCountBefore, err := getContainerCount()
  1414. if err != nil {
  1415. t.Fatalf("failed to get the container count: %s", err)
  1416. }
  1417. out, _, err := dockerCmdInDir(t, ctx.Dir, "build", "--rm=false", "-t", name, ".")
  1418. if err != nil {
  1419. t.Fatal("failed to build the image", out)
  1420. }
  1421. containerCountAfter, err := getContainerCount()
  1422. if err != nil {
  1423. t.Fatalf("failed to get the container count: %s", err)
  1424. }
  1425. if containerCountBefore == containerCountAfter {
  1426. t.Fatalf("--rm=false should have left containers behind")
  1427. }
  1428. deleteAllContainers()
  1429. deleteImages(name)
  1430. }
  1431. logDone("build - ensure --rm doesn't leave containers behind and that --rm=true is the default")
  1432. logDone("build - ensure --rm=false overrides the default")
  1433. }
  1434. func TestBuildWithVolumes(t *testing.T) {
  1435. var (
  1436. result map[string]map[string]struct{}
  1437. name = "testbuildvolumes"
  1438. emptyMap = make(map[string]struct{})
  1439. expected = map[string]map[string]struct{}{
  1440. "/test1": emptyMap,
  1441. "/test2": emptyMap,
  1442. "/test3": emptyMap,
  1443. "/test4": emptyMap,
  1444. "/test5": emptyMap,
  1445. "/test6": emptyMap,
  1446. "[/test7": emptyMap,
  1447. "/test8]": emptyMap,
  1448. }
  1449. )
  1450. defer deleteImages(name)
  1451. _, err := buildImage(name,
  1452. `FROM scratch
  1453. VOLUME /test1
  1454. VOLUME /test2
  1455. VOLUME /test3 /test4
  1456. VOLUME ["/test5", "/test6"]
  1457. VOLUME [/test7 /test8]
  1458. `,
  1459. true)
  1460. if err != nil {
  1461. t.Fatal(err)
  1462. }
  1463. res, err := inspectFieldJSON(name, "Config.Volumes")
  1464. if err != nil {
  1465. t.Fatal(err)
  1466. }
  1467. err = unmarshalJSON([]byte(res), &result)
  1468. if err != nil {
  1469. t.Fatal(err)
  1470. }
  1471. equal := reflect.DeepEqual(&result, &expected)
  1472. if !equal {
  1473. t.Fatalf("Volumes %s, expected %s", result, expected)
  1474. }
  1475. logDone("build - with volumes")
  1476. }
  1477. func TestBuildMaintainer(t *testing.T) {
  1478. name := "testbuildmaintainer"
  1479. expected := "dockerio"
  1480. defer deleteImages(name)
  1481. _, err := buildImage(name,
  1482. `FROM scratch
  1483. MAINTAINER dockerio`,
  1484. true)
  1485. if err != nil {
  1486. t.Fatal(err)
  1487. }
  1488. res, err := inspectField(name, "Author")
  1489. if err != nil {
  1490. t.Fatal(err)
  1491. }
  1492. if res != expected {
  1493. t.Fatalf("Maintainer %s, expected %s", res, expected)
  1494. }
  1495. logDone("build - maintainer")
  1496. }
  1497. func TestBuildUser(t *testing.T) {
  1498. name := "testbuilduser"
  1499. expected := "dockerio"
  1500. defer deleteImages(name)
  1501. _, err := buildImage(name,
  1502. `FROM busybox
  1503. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  1504. USER dockerio
  1505. RUN [ $(whoami) = 'dockerio' ]`,
  1506. true)
  1507. if err != nil {
  1508. t.Fatal(err)
  1509. }
  1510. res, err := inspectField(name, "Config.User")
  1511. if err != nil {
  1512. t.Fatal(err)
  1513. }
  1514. if res != expected {
  1515. t.Fatalf("User %s, expected %s", res, expected)
  1516. }
  1517. logDone("build - user")
  1518. }
  1519. func TestBuildRelativeWorkdir(t *testing.T) {
  1520. name := "testbuildrelativeworkdir"
  1521. expected := "/test2/test3"
  1522. defer deleteImages(name)
  1523. _, err := buildImage(name,
  1524. `FROM busybox
  1525. RUN [ "$PWD" = '/' ]
  1526. WORKDIR test1
  1527. RUN [ "$PWD" = '/test1' ]
  1528. WORKDIR /test2
  1529. RUN [ "$PWD" = '/test2' ]
  1530. WORKDIR test3
  1531. RUN [ "$PWD" = '/test2/test3' ]`,
  1532. true)
  1533. if err != nil {
  1534. t.Fatal(err)
  1535. }
  1536. res, err := inspectField(name, "Config.WorkingDir")
  1537. if err != nil {
  1538. t.Fatal(err)
  1539. }
  1540. if res != expected {
  1541. t.Fatalf("Workdir %s, expected %s", res, expected)
  1542. }
  1543. logDone("build - relative workdir")
  1544. }
  1545. func TestBuildWorkdirWithEnvVariables(t *testing.T) {
  1546. name := "testbuildworkdirwithenvvariables"
  1547. expected := "/test1/test2/$MISSING_VAR"
  1548. defer deleteImages(name)
  1549. _, err := buildImage(name,
  1550. `FROM busybox
  1551. ENV DIRPATH /test1
  1552. ENV SUBDIRNAME test2
  1553. WORKDIR $DIRPATH
  1554. WORKDIR $SUBDIRNAME/$MISSING_VAR`,
  1555. true)
  1556. if err != nil {
  1557. t.Fatal(err)
  1558. }
  1559. res, err := inspectField(name, "Config.WorkingDir")
  1560. if err != nil {
  1561. t.Fatal(err)
  1562. }
  1563. if res != expected {
  1564. t.Fatalf("Workdir %s, expected %s", res, expected)
  1565. }
  1566. logDone("build - workdir with env variables")
  1567. }
  1568. func TestBuildEnv(t *testing.T) {
  1569. name := "testbuildenv"
  1570. expected := "[PATH=/test:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin PORT=2375]"
  1571. defer deleteImages(name)
  1572. _, err := buildImage(name,
  1573. `FROM busybox
  1574. ENV PATH /test:$PATH
  1575. ENV PORT 2375
  1576. RUN [ $(env | grep PORT) = 'PORT=2375' ]`,
  1577. true)
  1578. if err != nil {
  1579. t.Fatal(err)
  1580. }
  1581. res, err := inspectField(name, "Config.Env")
  1582. if err != nil {
  1583. t.Fatal(err)
  1584. }
  1585. if res != expected {
  1586. t.Fatalf("Env %s, expected %s", res, expected)
  1587. }
  1588. logDone("build - env")
  1589. }
  1590. func TestBuildContextCleanup(t *testing.T) {
  1591. name := "testbuildcontextcleanup"
  1592. defer deleteImages(name)
  1593. entries, err := ioutil.ReadDir("/var/lib/docker/tmp")
  1594. if err != nil {
  1595. t.Fatalf("failed to list contents of tmp dir: %s", err)
  1596. }
  1597. _, err = buildImage(name,
  1598. `FROM scratch
  1599. ENTRYPOINT ["/bin/echo"]`,
  1600. true)
  1601. if err != nil {
  1602. t.Fatal(err)
  1603. }
  1604. entriesFinal, err := ioutil.ReadDir("/var/lib/docker/tmp")
  1605. if err != nil {
  1606. t.Fatalf("failed to list contents of tmp dir: %s", err)
  1607. }
  1608. if err = compareDirectoryEntries(entries, entriesFinal); err != nil {
  1609. t.Fatalf("context should have been deleted, but wasn't")
  1610. }
  1611. logDone("build - verify context cleanup works properly")
  1612. }
  1613. func TestBuildContextCleanupFailedBuild(t *testing.T) {
  1614. name := "testbuildcontextcleanup"
  1615. defer deleteImages(name)
  1616. defer deleteAllContainers()
  1617. entries, err := ioutil.ReadDir("/var/lib/docker/tmp")
  1618. if err != nil {
  1619. t.Fatalf("failed to list contents of tmp dir: %s", err)
  1620. }
  1621. _, err = buildImage(name,
  1622. `FROM scratch
  1623. RUN /non/existing/command`,
  1624. true)
  1625. if err == nil {
  1626. t.Fatalf("expected build to fail, but it didn't")
  1627. }
  1628. entriesFinal, err := ioutil.ReadDir("/var/lib/docker/tmp")
  1629. if err != nil {
  1630. t.Fatalf("failed to list contents of tmp dir: %s", err)
  1631. }
  1632. if err = compareDirectoryEntries(entries, entriesFinal); err != nil {
  1633. t.Fatalf("context should have been deleted, but wasn't")
  1634. }
  1635. logDone("build - verify context cleanup works properly after a failed build")
  1636. }
  1637. func TestBuildCmd(t *testing.T) {
  1638. name := "testbuildcmd"
  1639. expected := "[/bin/echo Hello World]"
  1640. defer deleteImages(name)
  1641. _, err := buildImage(name,
  1642. `FROM scratch
  1643. CMD ["/bin/echo", "Hello World"]`,
  1644. true)
  1645. if err != nil {
  1646. t.Fatal(err)
  1647. }
  1648. res, err := inspectField(name, "Config.Cmd")
  1649. if err != nil {
  1650. t.Fatal(err)
  1651. }
  1652. if res != expected {
  1653. t.Fatalf("Cmd %s, expected %s", res, expected)
  1654. }
  1655. logDone("build - cmd")
  1656. }
  1657. func TestBuildExpose(t *testing.T) {
  1658. name := "testbuildexpose"
  1659. expected := "map[2375/tcp:map[]]"
  1660. defer deleteImages(name)
  1661. _, err := buildImage(name,
  1662. `FROM scratch
  1663. EXPOSE 2375`,
  1664. true)
  1665. if err != nil {
  1666. t.Fatal(err)
  1667. }
  1668. res, err := inspectField(name, "Config.ExposedPorts")
  1669. if err != nil {
  1670. t.Fatal(err)
  1671. }
  1672. if res != expected {
  1673. t.Fatalf("Exposed ports %s, expected %s", res, expected)
  1674. }
  1675. logDone("build - expose")
  1676. }
  1677. func TestBuildExposeMorePorts(t *testing.T) {
  1678. // start building docker file with a large number of ports
  1679. portList := make([]string, 50)
  1680. line := make([]string, 100)
  1681. expectedPorts := make([]int, len(portList)*len(line))
  1682. for i := 0; i < len(portList); i++ {
  1683. for j := 0; j < len(line); j++ {
  1684. p := i*len(line) + j + 1
  1685. line[j] = strconv.Itoa(p)
  1686. expectedPorts[p-1] = p
  1687. }
  1688. if i == len(portList)-1 {
  1689. portList[i] = strings.Join(line, " ")
  1690. } else {
  1691. portList[i] = strings.Join(line, " ") + ` \`
  1692. }
  1693. }
  1694. dockerfile := `FROM scratch
  1695. EXPOSE {{range .}} {{.}}
  1696. {{end}}`
  1697. tmpl := template.Must(template.New("dockerfile").Parse(dockerfile))
  1698. buf := bytes.NewBuffer(nil)
  1699. tmpl.Execute(buf, portList)
  1700. name := "testbuildexpose"
  1701. defer deleteImages(name)
  1702. _, err := buildImage(name, buf.String(), true)
  1703. if err != nil {
  1704. t.Fatal(err)
  1705. }
  1706. // check if all the ports are saved inside Config.ExposedPorts
  1707. res, err := inspectFieldJSON(name, "Config.ExposedPorts")
  1708. if err != nil {
  1709. t.Fatal(err)
  1710. }
  1711. var exposedPorts map[string]interface{}
  1712. if err := json.Unmarshal([]byte(res), &exposedPorts); err != nil {
  1713. t.Fatal(err)
  1714. }
  1715. for _, p := range expectedPorts {
  1716. ep := fmt.Sprintf("%d/tcp", p)
  1717. if _, ok := exposedPorts[ep]; !ok {
  1718. t.Errorf("Port(%s) is not exposed", ep)
  1719. } else {
  1720. delete(exposedPorts, ep)
  1721. }
  1722. }
  1723. if len(exposedPorts) != 0 {
  1724. t.Errorf("Unexpected extra exposed ports %v", exposedPorts)
  1725. }
  1726. logDone("build - expose large number of ports")
  1727. }
  1728. func TestBuildExposeOrder(t *testing.T) {
  1729. buildID := func(name, exposed string) string {
  1730. _, err := buildImage(name, fmt.Sprintf(`FROM scratch
  1731. EXPOSE %s`, exposed), true)
  1732. if err != nil {
  1733. t.Fatal(err)
  1734. }
  1735. id, err := inspectField(name, "Id")
  1736. if err != nil {
  1737. t.Fatal(err)
  1738. }
  1739. return id
  1740. }
  1741. id1 := buildID("testbuildexpose1", "80 2375")
  1742. id2 := buildID("testbuildexpose2", "2375 80")
  1743. defer deleteImages("testbuildexpose1", "testbuildexpose2")
  1744. if id1 != id2 {
  1745. t.Errorf("EXPOSE should invalidate the cache only when ports actually changed")
  1746. }
  1747. logDone("build - expose order")
  1748. }
  1749. func TestBuildEmptyEntrypointInheritance(t *testing.T) {
  1750. name := "testbuildentrypointinheritance"
  1751. name2 := "testbuildentrypointinheritance2"
  1752. defer deleteImages(name, name2)
  1753. _, err := buildImage(name,
  1754. `FROM busybox
  1755. ENTRYPOINT ["/bin/echo"]`,
  1756. true)
  1757. if err != nil {
  1758. t.Fatal(err)
  1759. }
  1760. res, err := inspectField(name, "Config.Entrypoint")
  1761. if err != nil {
  1762. t.Fatal(err)
  1763. }
  1764. expected := "[/bin/echo]"
  1765. if res != expected {
  1766. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  1767. }
  1768. _, err = buildImage(name2,
  1769. fmt.Sprintf(`FROM %s
  1770. ENTRYPOINT []`, name),
  1771. true)
  1772. if err != nil {
  1773. t.Fatal(err)
  1774. }
  1775. res, err = inspectField(name2, "Config.Entrypoint")
  1776. if err != nil {
  1777. t.Fatal(err)
  1778. }
  1779. expected = "[]"
  1780. if res != expected {
  1781. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  1782. }
  1783. logDone("build - empty entrypoint inheritance")
  1784. }
  1785. func TestBuildEmptyEntrypoint(t *testing.T) {
  1786. name := "testbuildentrypoint"
  1787. defer deleteImages(name)
  1788. expected := "[]"
  1789. _, err := buildImage(name,
  1790. `FROM busybox
  1791. ENTRYPOINT []`,
  1792. true)
  1793. if err != nil {
  1794. t.Fatal(err)
  1795. }
  1796. res, err := inspectField(name, "Config.Entrypoint")
  1797. if err != nil {
  1798. t.Fatal(err)
  1799. }
  1800. if res != expected {
  1801. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  1802. }
  1803. logDone("build - empty entrypoint")
  1804. }
  1805. func TestBuildEntrypoint(t *testing.T) {
  1806. name := "testbuildentrypoint"
  1807. expected := "[/bin/echo]"
  1808. defer deleteImages(name)
  1809. _, err := buildImage(name,
  1810. `FROM scratch
  1811. ENTRYPOINT ["/bin/echo"]`,
  1812. true)
  1813. if err != nil {
  1814. t.Fatal(err)
  1815. }
  1816. res, err := inspectField(name, "Config.Entrypoint")
  1817. if err != nil {
  1818. t.Fatal(err)
  1819. }
  1820. if res != expected {
  1821. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  1822. }
  1823. logDone("build - entrypoint")
  1824. }
  1825. // #6445 ensure ONBUILD triggers aren't committed to grandchildren
  1826. func TestBuildOnBuildLimitedInheritence(t *testing.T) {
  1827. var (
  1828. out2, out3 string
  1829. )
  1830. {
  1831. name1 := "testonbuildtrigger1"
  1832. dockerfile1 := `
  1833. FROM busybox
  1834. RUN echo "GRANDPARENT"
  1835. ONBUILD RUN echo "ONBUILD PARENT"
  1836. `
  1837. ctx, err := fakeContext(dockerfile1, nil)
  1838. if err != nil {
  1839. t.Fatal(err)
  1840. }
  1841. defer ctx.Close()
  1842. out1, _, err := dockerCmdInDir(t, ctx.Dir, "build", "-t", name1, ".")
  1843. if err != nil {
  1844. t.Fatalf("build failed to complete: %s, %v", out1, err)
  1845. }
  1846. defer deleteImages(name1)
  1847. }
  1848. {
  1849. name2 := "testonbuildtrigger2"
  1850. dockerfile2 := `
  1851. FROM testonbuildtrigger1
  1852. `
  1853. ctx, err := fakeContext(dockerfile2, nil)
  1854. if err != nil {
  1855. t.Fatal(err)
  1856. }
  1857. defer ctx.Close()
  1858. out2, _, err = dockerCmdInDir(t, ctx.Dir, "build", "-t", name2, ".")
  1859. if err != nil {
  1860. t.Fatalf("build failed to complete: %s, %v", out2, err)
  1861. }
  1862. defer deleteImages(name2)
  1863. }
  1864. {
  1865. name3 := "testonbuildtrigger3"
  1866. dockerfile3 := `
  1867. FROM testonbuildtrigger2
  1868. `
  1869. ctx, err := fakeContext(dockerfile3, nil)
  1870. if err != nil {
  1871. t.Fatal(err)
  1872. }
  1873. defer ctx.Close()
  1874. out3, _, err = dockerCmdInDir(t, ctx.Dir, "build", "-t", name3, ".")
  1875. if err != nil {
  1876. t.Fatalf("build failed to complete: %s, %v", out3, err)
  1877. }
  1878. defer deleteImages(name3)
  1879. }
  1880. // ONBUILD should be run in second build.
  1881. if !strings.Contains(out2, "ONBUILD PARENT") {
  1882. t.Fatalf("ONBUILD instruction did not run in child of ONBUILD parent")
  1883. }
  1884. // ONBUILD should *not* be run in third build.
  1885. if strings.Contains(out3, "ONBUILD PARENT") {
  1886. t.Fatalf("ONBUILD instruction ran in grandchild of ONBUILD parent")
  1887. }
  1888. logDone("build - onbuild")
  1889. }
  1890. func TestBuildWithCache(t *testing.T) {
  1891. name := "testbuildwithcache"
  1892. defer deleteImages(name)
  1893. id1, err := buildImage(name,
  1894. `FROM scratch
  1895. MAINTAINER dockerio
  1896. EXPOSE 5432
  1897. ENTRYPOINT ["/bin/echo"]`,
  1898. true)
  1899. if err != nil {
  1900. t.Fatal(err)
  1901. }
  1902. id2, err := buildImage(name,
  1903. `FROM scratch
  1904. MAINTAINER dockerio
  1905. EXPOSE 5432
  1906. ENTRYPOINT ["/bin/echo"]`,
  1907. true)
  1908. if err != nil {
  1909. t.Fatal(err)
  1910. }
  1911. if id1 != id2 {
  1912. t.Fatal("The cache should have been used but hasn't.")
  1913. }
  1914. logDone("build - with cache")
  1915. }
  1916. func TestBuildWithoutCache(t *testing.T) {
  1917. name := "testbuildwithoutcache"
  1918. name2 := "testbuildwithoutcache2"
  1919. defer deleteImages(name, name2)
  1920. id1, err := buildImage(name,
  1921. `FROM scratch
  1922. MAINTAINER dockerio
  1923. EXPOSE 5432
  1924. ENTRYPOINT ["/bin/echo"]`,
  1925. true)
  1926. if err != nil {
  1927. t.Fatal(err)
  1928. }
  1929. id2, err := buildImage(name2,
  1930. `FROM scratch
  1931. MAINTAINER dockerio
  1932. EXPOSE 5432
  1933. ENTRYPOINT ["/bin/echo"]`,
  1934. false)
  1935. if err != nil {
  1936. t.Fatal(err)
  1937. }
  1938. if id1 == id2 {
  1939. t.Fatal("The cache should have been invalided but hasn't.")
  1940. }
  1941. logDone("build - without cache")
  1942. }
  1943. func TestBuildADDLocalFileWithCache(t *testing.T) {
  1944. name := "testbuildaddlocalfilewithcache"
  1945. name2 := "testbuildaddlocalfilewithcache2"
  1946. defer deleteImages(name, name2)
  1947. dockerfile := `
  1948. FROM busybox
  1949. MAINTAINER dockerio
  1950. ADD foo /usr/lib/bla/bar
  1951. RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
  1952. ctx, err := fakeContext(dockerfile, map[string]string{
  1953. "foo": "hello",
  1954. })
  1955. defer ctx.Close()
  1956. if err != nil {
  1957. t.Fatal(err)
  1958. }
  1959. id1, err := buildImageFromContext(name, ctx, true)
  1960. if err != nil {
  1961. t.Fatal(err)
  1962. }
  1963. id2, err := buildImageFromContext(name2, ctx, true)
  1964. if err != nil {
  1965. t.Fatal(err)
  1966. }
  1967. if id1 != id2 {
  1968. t.Fatal("The cache should have been used but hasn't.")
  1969. }
  1970. logDone("build - add local file with cache")
  1971. }
  1972. func TestBuildADDMultipleLocalFileWithCache(t *testing.T) {
  1973. name := "testbuildaddmultiplelocalfilewithcache"
  1974. name2 := "testbuildaddmultiplelocalfilewithcache2"
  1975. defer deleteImages(name, name2)
  1976. dockerfile := `
  1977. FROM busybox
  1978. MAINTAINER dockerio
  1979. ADD foo Dockerfile /usr/lib/bla/
  1980. RUN [ "$(cat /usr/lib/bla/foo)" = "hello" ]`
  1981. ctx, err := fakeContext(dockerfile, map[string]string{
  1982. "foo": "hello",
  1983. })
  1984. defer ctx.Close()
  1985. if err != nil {
  1986. t.Fatal(err)
  1987. }
  1988. id1, err := buildImageFromContext(name, ctx, true)
  1989. if err != nil {
  1990. t.Fatal(err)
  1991. }
  1992. id2, err := buildImageFromContext(name2, ctx, true)
  1993. if err != nil {
  1994. t.Fatal(err)
  1995. }
  1996. if id1 != id2 {
  1997. t.Fatal("The cache should have been used but hasn't.")
  1998. }
  1999. logDone("build - add multiple local files with cache")
  2000. }
  2001. func TestBuildADDLocalFileWithoutCache(t *testing.T) {
  2002. name := "testbuildaddlocalfilewithoutcache"
  2003. name2 := "testbuildaddlocalfilewithoutcache2"
  2004. defer deleteImages(name, name2)
  2005. dockerfile := `
  2006. FROM busybox
  2007. MAINTAINER dockerio
  2008. ADD foo /usr/lib/bla/bar
  2009. RUN [ "$(cat /usr/lib/bla/bar)" = "hello" ]`
  2010. ctx, err := fakeContext(dockerfile, map[string]string{
  2011. "foo": "hello",
  2012. })
  2013. defer ctx.Close()
  2014. if err != nil {
  2015. t.Fatal(err)
  2016. }
  2017. id1, err := buildImageFromContext(name, ctx, true)
  2018. if err != nil {
  2019. t.Fatal(err)
  2020. }
  2021. id2, err := buildImageFromContext(name2, ctx, false)
  2022. if err != nil {
  2023. t.Fatal(err)
  2024. }
  2025. if id1 == id2 {
  2026. t.Fatal("The cache should have been invalided but hasn't.")
  2027. }
  2028. logDone("build - add local file without cache")
  2029. }
  2030. func TestBuildCopyDirButNotFile(t *testing.T) {
  2031. name := "testbuildcopydirbutnotfile"
  2032. name2 := "testbuildcopydirbutnotfile2"
  2033. defer deleteImages(name, name2)
  2034. dockerfile := `
  2035. FROM scratch
  2036. COPY dir /tmp/`
  2037. ctx, err := fakeContext(dockerfile, map[string]string{
  2038. "dir/foo": "hello",
  2039. })
  2040. defer ctx.Close()
  2041. if err != nil {
  2042. t.Fatal(err)
  2043. }
  2044. id1, err := buildImageFromContext(name, ctx, true)
  2045. if err != nil {
  2046. t.Fatal(err)
  2047. }
  2048. // Check that adding file with similar name doesn't mess with cache
  2049. if err := ctx.Add("dir_file", "hello2"); err != nil {
  2050. t.Fatal(err)
  2051. }
  2052. id2, err := buildImageFromContext(name2, ctx, true)
  2053. if err != nil {
  2054. t.Fatal(err)
  2055. }
  2056. if id1 != id2 {
  2057. t.Fatal("The cache should have been used but wasn't")
  2058. }
  2059. logDone("build - add current directory but not file")
  2060. }
  2061. func TestBuildADDCurrentDirWithCache(t *testing.T) {
  2062. name := "testbuildaddcurrentdirwithcache"
  2063. name2 := name + "2"
  2064. name3 := name + "3"
  2065. name4 := name + "4"
  2066. name5 := name + "5"
  2067. defer deleteImages(name, name2, name3, name4, name5)
  2068. dockerfile := `
  2069. FROM scratch
  2070. MAINTAINER dockerio
  2071. ADD . /usr/lib/bla`
  2072. ctx, err := fakeContext(dockerfile, map[string]string{
  2073. "foo": "hello",
  2074. })
  2075. defer ctx.Close()
  2076. if err != nil {
  2077. t.Fatal(err)
  2078. }
  2079. id1, err := buildImageFromContext(name, ctx, true)
  2080. if err != nil {
  2081. t.Fatal(err)
  2082. }
  2083. // Check that adding file invalidate cache of "ADD ."
  2084. if err := ctx.Add("bar", "hello2"); err != nil {
  2085. t.Fatal(err)
  2086. }
  2087. id2, err := buildImageFromContext(name2, ctx, true)
  2088. if err != nil {
  2089. t.Fatal(err)
  2090. }
  2091. if id1 == id2 {
  2092. t.Fatal("The cache should have been invalided but hasn't.")
  2093. }
  2094. // Check that changing file invalidate cache of "ADD ."
  2095. if err := ctx.Add("foo", "hello1"); err != nil {
  2096. t.Fatal(err)
  2097. }
  2098. id3, err := buildImageFromContext(name3, ctx, true)
  2099. if err != nil {
  2100. t.Fatal(err)
  2101. }
  2102. if id2 == id3 {
  2103. t.Fatal("The cache should have been invalided but hasn't.")
  2104. }
  2105. // Check that changing file to same content invalidate cache of "ADD ."
  2106. time.Sleep(1 * time.Second) // wait second because of mtime precision
  2107. if err := ctx.Add("foo", "hello1"); err != nil {
  2108. t.Fatal(err)
  2109. }
  2110. id4, err := buildImageFromContext(name4, ctx, true)
  2111. if err != nil {
  2112. t.Fatal(err)
  2113. }
  2114. if id3 == id4 {
  2115. t.Fatal("The cache should have been invalided but hasn't.")
  2116. }
  2117. id5, err := buildImageFromContext(name5, ctx, true)
  2118. if err != nil {
  2119. t.Fatal(err)
  2120. }
  2121. if id4 != id5 {
  2122. t.Fatal("The cache should have been used but hasn't.")
  2123. }
  2124. logDone("build - add current directory with cache")
  2125. }
  2126. func TestBuildADDCurrentDirWithoutCache(t *testing.T) {
  2127. name := "testbuildaddcurrentdirwithoutcache"
  2128. name2 := "testbuildaddcurrentdirwithoutcache2"
  2129. defer deleteImages(name, name2)
  2130. dockerfile := `
  2131. FROM scratch
  2132. MAINTAINER dockerio
  2133. ADD . /usr/lib/bla`
  2134. ctx, err := fakeContext(dockerfile, map[string]string{
  2135. "foo": "hello",
  2136. })
  2137. defer ctx.Close()
  2138. if err != nil {
  2139. t.Fatal(err)
  2140. }
  2141. id1, err := buildImageFromContext(name, ctx, true)
  2142. if err != nil {
  2143. t.Fatal(err)
  2144. }
  2145. id2, err := buildImageFromContext(name2, ctx, false)
  2146. if err != nil {
  2147. t.Fatal(err)
  2148. }
  2149. if id1 == id2 {
  2150. t.Fatal("The cache should have been invalided but hasn't.")
  2151. }
  2152. logDone("build - add current directory without cache")
  2153. }
  2154. func TestBuildADDRemoteFileWithCache(t *testing.T) {
  2155. name := "testbuildaddremotefilewithcache"
  2156. defer deleteImages(name)
  2157. server, err := fakeStorage(map[string]string{
  2158. "baz": "hello",
  2159. })
  2160. if err != nil {
  2161. t.Fatal(err)
  2162. }
  2163. defer server.Close()
  2164. id1, err := buildImage(name,
  2165. fmt.Sprintf(`FROM scratch
  2166. MAINTAINER dockerio
  2167. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2168. true)
  2169. if err != nil {
  2170. t.Fatal(err)
  2171. }
  2172. id2, err := buildImage(name,
  2173. fmt.Sprintf(`FROM scratch
  2174. MAINTAINER dockerio
  2175. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2176. true)
  2177. if err != nil {
  2178. t.Fatal(err)
  2179. }
  2180. if id1 != id2 {
  2181. t.Fatal("The cache should have been used but hasn't.")
  2182. }
  2183. logDone("build - add remote file with cache")
  2184. }
  2185. func TestBuildADDRemoteFileWithoutCache(t *testing.T) {
  2186. name := "testbuildaddremotefilewithoutcache"
  2187. name2 := "testbuildaddremotefilewithoutcache2"
  2188. defer deleteImages(name, name2)
  2189. server, err := fakeStorage(map[string]string{
  2190. "baz": "hello",
  2191. })
  2192. if err != nil {
  2193. t.Fatal(err)
  2194. }
  2195. defer server.Close()
  2196. id1, err := buildImage(name,
  2197. fmt.Sprintf(`FROM scratch
  2198. MAINTAINER dockerio
  2199. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2200. true)
  2201. if err != nil {
  2202. t.Fatal(err)
  2203. }
  2204. id2, err := buildImage(name2,
  2205. fmt.Sprintf(`FROM scratch
  2206. MAINTAINER dockerio
  2207. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2208. false)
  2209. if err != nil {
  2210. t.Fatal(err)
  2211. }
  2212. if id1 == id2 {
  2213. t.Fatal("The cache should have been invalided but hasn't.")
  2214. }
  2215. logDone("build - add remote file without cache")
  2216. }
  2217. func TestBuildADDRemoteFileMTime(t *testing.T) {
  2218. name := "testbuildaddremotefilemtime"
  2219. name2 := name + "2"
  2220. name3 := name + "3"
  2221. name4 := name + "4"
  2222. defer deleteImages(name, name2, name3, name4)
  2223. server, err := fakeStorage(map[string]string{"baz": "hello"})
  2224. if err != nil {
  2225. t.Fatal(err)
  2226. }
  2227. defer server.Close()
  2228. ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
  2229. MAINTAINER dockerio
  2230. ADD %s/baz /usr/lib/baz/quux`, server.URL), nil)
  2231. if err != nil {
  2232. t.Fatal(err)
  2233. }
  2234. defer ctx.Close()
  2235. id1, err := buildImageFromContext(name, ctx, true)
  2236. if err != nil {
  2237. t.Fatal(err)
  2238. }
  2239. id2, err := buildImageFromContext(name2, ctx, true)
  2240. if err != nil {
  2241. t.Fatal(err)
  2242. }
  2243. if id1 != id2 {
  2244. t.Fatal("The cache should have been used but wasn't - #1")
  2245. }
  2246. // Now set baz's times to anything else and redo the build
  2247. // This time the cache should not be used
  2248. bazPath := path.Join(server.FakeContext.Dir, "baz")
  2249. err = syscall.UtimesNano(bazPath, make([]syscall.Timespec, 2))
  2250. if err != nil {
  2251. t.Fatalf("Error setting mtime on %q: %v", bazPath, err)
  2252. }
  2253. id3, err := buildImageFromContext(name3, ctx, true)
  2254. if err != nil {
  2255. t.Fatal(err)
  2256. }
  2257. if id1 == id3 {
  2258. t.Fatal("The cache should not have been used but was")
  2259. }
  2260. // And for good measure do it again and make sure cache is used this time
  2261. id4, err := buildImageFromContext(name4, ctx, true)
  2262. if err != nil {
  2263. t.Fatal(err)
  2264. }
  2265. if id3 != id4 {
  2266. t.Fatal("The cache should have been used but wasn't - #2")
  2267. }
  2268. logDone("build - add remote file testing mtime")
  2269. }
  2270. func TestBuildADDLocalAndRemoteFilesWithCache(t *testing.T) {
  2271. name := "testbuildaddlocalandremotefilewithcache"
  2272. defer deleteImages(name)
  2273. server, err := fakeStorage(map[string]string{
  2274. "baz": "hello",
  2275. })
  2276. if err != nil {
  2277. t.Fatal(err)
  2278. }
  2279. defer server.Close()
  2280. ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
  2281. MAINTAINER dockerio
  2282. ADD foo /usr/lib/bla/bar
  2283. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2284. map[string]string{
  2285. "foo": "hello world",
  2286. })
  2287. if err != nil {
  2288. t.Fatal(err)
  2289. }
  2290. defer ctx.Close()
  2291. id1, err := buildImageFromContext(name, ctx, true)
  2292. if err != nil {
  2293. t.Fatal(err)
  2294. }
  2295. id2, err := buildImageFromContext(name, ctx, true)
  2296. if err != nil {
  2297. t.Fatal(err)
  2298. }
  2299. if id1 != id2 {
  2300. t.Fatal("The cache should have been used but hasn't.")
  2301. }
  2302. logDone("build - add local and remote file with cache")
  2303. }
  2304. func testContextTar(t *testing.T, compression archive.Compression) {
  2305. ctx, err := fakeContext(
  2306. `FROM busybox
  2307. ADD foo /foo
  2308. CMD ["cat", "/foo"]`,
  2309. map[string]string{
  2310. "foo": "bar",
  2311. },
  2312. )
  2313. defer ctx.Close()
  2314. if err != nil {
  2315. t.Fatal(err)
  2316. }
  2317. context, err := archive.Tar(ctx.Dir, compression)
  2318. if err != nil {
  2319. t.Fatalf("failed to build context tar: %v", err)
  2320. }
  2321. name := "contexttar"
  2322. buildCmd := exec.Command(dockerBinary, "build", "-t", name, "-")
  2323. defer deleteImages(name)
  2324. buildCmd.Stdin = context
  2325. if out, _, err := runCommandWithOutput(buildCmd); err != nil {
  2326. t.Fatalf("build failed to complete: %v %v", out, err)
  2327. }
  2328. logDone(fmt.Sprintf("build - build an image with a context tar, compression: %v", compression))
  2329. }
  2330. func TestBuildContextTarGzip(t *testing.T) {
  2331. testContextTar(t, archive.Gzip)
  2332. }
  2333. func TestBuildContextTarNoCompression(t *testing.T) {
  2334. testContextTar(t, archive.Uncompressed)
  2335. }
  2336. func TestBuildNoContext(t *testing.T) {
  2337. buildCmd := exec.Command(dockerBinary, "build", "-t", "nocontext", "-")
  2338. buildCmd.Stdin = strings.NewReader("FROM busybox\nCMD echo ok\n")
  2339. if out, _, err := runCommandWithOutput(buildCmd); err != nil {
  2340. t.Fatalf("build failed to complete: %v %v", out, err)
  2341. }
  2342. if out, _, err := dockerCmd(t, "run", "--rm", "nocontext"); out != "ok\n" || err != nil {
  2343. t.Fatalf("run produced invalid output: %q, expected %q", out, "ok")
  2344. }
  2345. deleteImages("nocontext")
  2346. logDone("build - build an image with no context")
  2347. }
  2348. // TODO: TestCaching
  2349. func TestBuildADDLocalAndRemoteFilesWithoutCache(t *testing.T) {
  2350. name := "testbuildaddlocalandremotefilewithoutcache"
  2351. name2 := "testbuildaddlocalandremotefilewithoutcache2"
  2352. defer deleteImages(name, name2)
  2353. server, err := fakeStorage(map[string]string{
  2354. "baz": "hello",
  2355. })
  2356. if err != nil {
  2357. t.Fatal(err)
  2358. }
  2359. defer server.Close()
  2360. ctx, err := fakeContext(fmt.Sprintf(`FROM scratch
  2361. MAINTAINER dockerio
  2362. ADD foo /usr/lib/bla/bar
  2363. ADD %s/baz /usr/lib/baz/quux`, server.URL),
  2364. map[string]string{
  2365. "foo": "hello world",
  2366. })
  2367. if err != nil {
  2368. t.Fatal(err)
  2369. }
  2370. defer ctx.Close()
  2371. id1, err := buildImageFromContext(name, ctx, true)
  2372. if err != nil {
  2373. t.Fatal(err)
  2374. }
  2375. id2, err := buildImageFromContext(name2, ctx, false)
  2376. if err != nil {
  2377. t.Fatal(err)
  2378. }
  2379. if id1 == id2 {
  2380. t.Fatal("The cache should have been invalided but hasn't.")
  2381. }
  2382. logDone("build - add local and remote file without cache")
  2383. }
  2384. func TestBuildWithVolumeOwnership(t *testing.T) {
  2385. name := "testbuildimg"
  2386. defer deleteImages(name)
  2387. _, err := buildImage(name,
  2388. `FROM busybox:latest
  2389. RUN mkdir /test && chown daemon:daemon /test && chmod 0600 /test
  2390. VOLUME /test`,
  2391. true)
  2392. if err != nil {
  2393. t.Fatal(err)
  2394. }
  2395. cmd := exec.Command(dockerBinary, "run", "--rm", "testbuildimg", "ls", "-la", "/test")
  2396. out, _, err := runCommandWithOutput(cmd)
  2397. if err != nil {
  2398. t.Fatal(out, err)
  2399. }
  2400. if expected := "drw-------"; !strings.Contains(out, expected) {
  2401. t.Fatalf("expected %s received %s", expected, out)
  2402. }
  2403. if expected := "daemon daemon"; !strings.Contains(out, expected) {
  2404. t.Fatalf("expected %s received %s", expected, out)
  2405. }
  2406. logDone("build - volume ownership")
  2407. }
  2408. // testing #1405 - config.Cmd does not get cleaned up if
  2409. // utilizing cache
  2410. func TestBuildEntrypointRunCleanup(t *testing.T) {
  2411. name := "testbuildcmdcleanup"
  2412. defer deleteImages(name)
  2413. if _, err := buildImage(name,
  2414. `FROM busybox
  2415. RUN echo "hello"`,
  2416. true); err != nil {
  2417. t.Fatal(err)
  2418. }
  2419. ctx, err := fakeContext(`FROM busybox
  2420. RUN echo "hello"
  2421. ADD foo /foo
  2422. ENTRYPOINT ["/bin/echo"]`,
  2423. map[string]string{
  2424. "foo": "hello",
  2425. })
  2426. defer ctx.Close()
  2427. if err != nil {
  2428. t.Fatal(err)
  2429. }
  2430. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  2431. t.Fatal(err)
  2432. }
  2433. res, err := inspectField(name, "Config.Cmd")
  2434. if err != nil {
  2435. t.Fatal(err)
  2436. }
  2437. // Cmd must be cleaned up
  2438. if expected := "<no value>"; res != expected {
  2439. t.Fatalf("Cmd %s, expected %s", res, expected)
  2440. }
  2441. logDone("build - cleanup cmd after RUN")
  2442. }
  2443. func TestBuildForbiddenContextPath(t *testing.T) {
  2444. name := "testbuildforbidpath"
  2445. defer deleteImages(name)
  2446. ctx, err := fakeContext(`FROM scratch
  2447. ADD ../../ test/
  2448. `,
  2449. map[string]string{
  2450. "test.txt": "test1",
  2451. "other.txt": "other",
  2452. })
  2453. defer ctx.Close()
  2454. if err != nil {
  2455. t.Fatal(err)
  2456. }
  2457. expected := "Forbidden path outside the build context: ../../ "
  2458. if _, err := buildImageFromContext(name, ctx, true); err == nil || !strings.Contains(err.Error(), expected) {
  2459. t.Fatalf("Wrong error: (should contain \"%s\") got:\n%v", expected, err)
  2460. }
  2461. logDone("build - forbidden context path")
  2462. }
  2463. func TestBuildADDFileNotFound(t *testing.T) {
  2464. name := "testbuildaddnotfound"
  2465. defer deleteImages(name)
  2466. ctx, err := fakeContext(`FROM scratch
  2467. ADD foo /usr/local/bar`,
  2468. map[string]string{"bar": "hello"})
  2469. defer ctx.Close()
  2470. if err != nil {
  2471. t.Fatal(err)
  2472. }
  2473. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  2474. if !strings.Contains(err.Error(), "foo: no such file or directory") {
  2475. t.Fatalf("Wrong error %v, must be about missing foo file or directory", err)
  2476. }
  2477. } else {
  2478. t.Fatal("Error must not be nil")
  2479. }
  2480. logDone("build - add file not found")
  2481. }
  2482. func TestBuildInheritance(t *testing.T) {
  2483. name := "testbuildinheritance"
  2484. defer deleteImages(name)
  2485. _, err := buildImage(name,
  2486. `FROM scratch
  2487. EXPOSE 2375`,
  2488. true)
  2489. if err != nil {
  2490. t.Fatal(err)
  2491. }
  2492. ports1, err := inspectField(name, "Config.ExposedPorts")
  2493. if err != nil {
  2494. t.Fatal(err)
  2495. }
  2496. _, err = buildImage(name,
  2497. fmt.Sprintf(`FROM %s
  2498. ENTRYPOINT ["/bin/echo"]`, name),
  2499. true)
  2500. if err != nil {
  2501. t.Fatal(err)
  2502. }
  2503. res, err := inspectField(name, "Config.Entrypoint")
  2504. if err != nil {
  2505. t.Fatal(err)
  2506. }
  2507. if expected := "[/bin/echo]"; res != expected {
  2508. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  2509. }
  2510. ports2, err := inspectField(name, "Config.ExposedPorts")
  2511. if err != nil {
  2512. t.Fatal(err)
  2513. }
  2514. if ports1 != ports2 {
  2515. t.Fatalf("Ports must be same: %s != %s", ports1, ports2)
  2516. }
  2517. logDone("build - inheritance")
  2518. }
  2519. func TestBuildFails(t *testing.T) {
  2520. name := "testbuildfails"
  2521. defer deleteImages(name)
  2522. defer deleteAllContainers()
  2523. _, err := buildImage(name,
  2524. `FROM busybox
  2525. RUN sh -c "exit 23"`,
  2526. true)
  2527. if err != nil {
  2528. if !strings.Contains(err.Error(), "returned a non-zero code: 23") {
  2529. t.Fatalf("Wrong error %v, must be about non-zero code 23", err)
  2530. }
  2531. } else {
  2532. t.Fatal("Error must not be nil")
  2533. }
  2534. logDone("build - fails")
  2535. }
  2536. func TestBuildFailsDockerfileEmpty(t *testing.T) {
  2537. name := "testbuildfails"
  2538. defer deleteImages(name)
  2539. _, err := buildImage(name, ``, true)
  2540. if err != nil {
  2541. if !strings.Contains(err.Error(), "Dockerfile cannot be empty") {
  2542. t.Fatalf("Wrong error %v, must be about empty Dockerfile", err)
  2543. }
  2544. } else {
  2545. t.Fatal("Error must not be nil")
  2546. }
  2547. logDone("build - fails with empty dockerfile")
  2548. }
  2549. func TestBuildOnBuild(t *testing.T) {
  2550. name := "testbuildonbuild"
  2551. defer deleteImages(name)
  2552. _, err := buildImage(name,
  2553. `FROM busybox
  2554. ONBUILD RUN touch foobar`,
  2555. true)
  2556. if err != nil {
  2557. t.Fatal(err)
  2558. }
  2559. _, err = buildImage(name,
  2560. fmt.Sprintf(`FROM %s
  2561. RUN [ -f foobar ]`, name),
  2562. true)
  2563. if err != nil {
  2564. t.Fatal(err)
  2565. }
  2566. logDone("build - onbuild")
  2567. }
  2568. func TestBuildOnBuildForbiddenChained(t *testing.T) {
  2569. name := "testbuildonbuildforbiddenchained"
  2570. defer deleteImages(name)
  2571. _, err := buildImage(name,
  2572. `FROM busybox
  2573. ONBUILD ONBUILD RUN touch foobar`,
  2574. true)
  2575. if err != nil {
  2576. if !strings.Contains(err.Error(), "Chaining ONBUILD via `ONBUILD ONBUILD` isn't allowed") {
  2577. t.Fatalf("Wrong error %v, must be about chaining ONBUILD", err)
  2578. }
  2579. } else {
  2580. t.Fatal("Error must not be nil")
  2581. }
  2582. logDone("build - onbuild forbidden chained")
  2583. }
  2584. func TestBuildOnBuildForbiddenFrom(t *testing.T) {
  2585. name := "testbuildonbuildforbiddenfrom"
  2586. defer deleteImages(name)
  2587. _, err := buildImage(name,
  2588. `FROM busybox
  2589. ONBUILD FROM scratch`,
  2590. true)
  2591. if err != nil {
  2592. if !strings.Contains(err.Error(), "FROM isn't allowed as an ONBUILD trigger") {
  2593. t.Fatalf("Wrong error %v, must be about FROM forbidden", err)
  2594. }
  2595. } else {
  2596. t.Fatal("Error must not be nil")
  2597. }
  2598. logDone("build - onbuild forbidden from")
  2599. }
  2600. func TestBuildOnBuildForbiddenMaintainer(t *testing.T) {
  2601. name := "testbuildonbuildforbiddenmaintainer"
  2602. defer deleteImages(name)
  2603. _, err := buildImage(name,
  2604. `FROM busybox
  2605. ONBUILD MAINTAINER docker.io`,
  2606. true)
  2607. if err != nil {
  2608. if !strings.Contains(err.Error(), "MAINTAINER isn't allowed as an ONBUILD trigger") {
  2609. t.Fatalf("Wrong error %v, must be about MAINTAINER forbidden", err)
  2610. }
  2611. } else {
  2612. t.Fatal("Error must not be nil")
  2613. }
  2614. logDone("build - onbuild forbidden maintainer")
  2615. }
  2616. // gh #2446
  2617. func TestBuildAddToSymlinkDest(t *testing.T) {
  2618. name := "testbuildaddtosymlinkdest"
  2619. defer deleteImages(name)
  2620. ctx, err := fakeContext(`FROM busybox
  2621. RUN mkdir /foo
  2622. RUN ln -s /foo /bar
  2623. ADD foo /bar/
  2624. RUN [ -f /bar/foo ]
  2625. RUN [ -f /foo/foo ]`,
  2626. map[string]string{
  2627. "foo": "hello",
  2628. })
  2629. if err != nil {
  2630. t.Fatal(err)
  2631. }
  2632. defer ctx.Close()
  2633. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  2634. t.Fatal(err)
  2635. }
  2636. logDone("build - add to symlink destination")
  2637. }
  2638. func TestBuildEscapeWhitespace(t *testing.T) {
  2639. name := "testbuildescaping"
  2640. defer deleteImages(name)
  2641. _, err := buildImage(name, `
  2642. FROM busybox
  2643. MAINTAINER "Docker \
  2644. IO <io@\
  2645. docker.com>"
  2646. `, true)
  2647. res, err := inspectField(name, "Author")
  2648. if err != nil {
  2649. t.Fatal(err)
  2650. }
  2651. if res != "\"Docker IO <io@docker.com>\"" {
  2652. t.Fatalf("Parsed string did not match the escaped string. Got: %q", res)
  2653. }
  2654. logDone("build - validate escaping whitespace")
  2655. }
  2656. func TestBuildVerifyIntString(t *testing.T) {
  2657. // Verify that strings that look like ints are still passed as strings
  2658. name := "testbuildstringing"
  2659. defer deleteImages(name)
  2660. _, err := buildImage(name, `
  2661. FROM busybox
  2662. MAINTAINER 123
  2663. `, true)
  2664. out, rc, err := runCommandWithOutput(exec.Command(dockerBinary, "inspect", name))
  2665. if rc != 0 || err != nil {
  2666. t.Fatalf("Unexcepted error from inspect: rc: %v err: %v", rc, err)
  2667. }
  2668. if !strings.Contains(out, "\"123\"") {
  2669. t.Fatalf("Output does not contain the int as a string:\n%s", out)
  2670. }
  2671. logDone("build - verify int/strings as strings")
  2672. }
  2673. func TestBuildDockerignore(t *testing.T) {
  2674. name := "testbuilddockerignore"
  2675. defer deleteImages(name)
  2676. dockerfile := `
  2677. FROM busybox
  2678. ADD . /bla
  2679. RUN [[ -f /bla/src/x.go ]]
  2680. RUN [[ -f /bla/Makefile ]]
  2681. RUN [[ ! -e /bla/src/_vendor ]]
  2682. RUN [[ ! -e /bla/.gitignore ]]
  2683. RUN [[ ! -e /bla/README.md ]]
  2684. RUN [[ ! -e /bla/.git ]]`
  2685. ctx, err := fakeContext(dockerfile, map[string]string{
  2686. "Makefile": "all:",
  2687. ".git/HEAD": "ref: foo",
  2688. "src/x.go": "package main",
  2689. "src/_vendor/v.go": "package main",
  2690. ".gitignore": "",
  2691. "README.md": "readme",
  2692. ".dockerignore": ".git\npkg\n.gitignore\nsrc/_vendor\n*.md",
  2693. })
  2694. defer ctx.Close()
  2695. if err != nil {
  2696. t.Fatal(err)
  2697. }
  2698. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  2699. t.Fatal(err)
  2700. }
  2701. logDone("build - test .dockerignore")
  2702. }
  2703. func TestBuildDockerignoreCleanPaths(t *testing.T) {
  2704. name := "testbuilddockerignorecleanpaths"
  2705. defer deleteImages(name)
  2706. dockerfile := `
  2707. FROM busybox
  2708. ADD . /tmp/
  2709. RUN (! ls /tmp/foo) && (! ls /tmp/foo2) && (! ls /tmp/dir1/foo)`
  2710. ctx, err := fakeContext(dockerfile, map[string]string{
  2711. "foo": "foo",
  2712. "foo2": "foo2",
  2713. "dir1/foo": "foo in dir1",
  2714. ".dockerignore": "./foo\ndir1//foo\n./dir1/../foo2",
  2715. })
  2716. if err != nil {
  2717. t.Fatal(err)
  2718. }
  2719. defer ctx.Close()
  2720. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  2721. t.Fatal(err)
  2722. }
  2723. logDone("build - test .dockerignore with clean paths")
  2724. }
  2725. func TestBuildDockerignoringDockerfile(t *testing.T) {
  2726. name := "testbuilddockerignoredockerfile"
  2727. defer deleteImages(name)
  2728. dockerfile := `
  2729. FROM scratch`
  2730. ctx, err := fakeContext(dockerfile, map[string]string{
  2731. "Dockerfile": "FROM scratch",
  2732. ".dockerignore": "Dockerfile\n",
  2733. })
  2734. if err != nil {
  2735. t.Fatal(err)
  2736. }
  2737. defer ctx.Close()
  2738. if _, err = buildImageFromContext(name, ctx, true); err == nil {
  2739. t.Fatalf("Didn't get expected error from ignoring Dockerfile")
  2740. }
  2741. // now try it with ./Dockerfile
  2742. ctx.Add(".dockerignore", "./Dockerfile\n")
  2743. if _, err = buildImageFromContext(name, ctx, true); err == nil {
  2744. t.Fatalf("Didn't get expected error from ignoring ./Dockerfile")
  2745. }
  2746. logDone("build - test .dockerignore of Dockerfile")
  2747. }
  2748. func TestBuildDockerignoringWholeDir(t *testing.T) {
  2749. name := "testbuilddockerignorewholedir"
  2750. defer deleteImages(name)
  2751. dockerfile := `
  2752. FROM busybox
  2753. COPY . /
  2754. RUN [[ ! -e /.gitignore ]]
  2755. RUN [[ -f /Makefile ]]`
  2756. ctx, err := fakeContext(dockerfile, map[string]string{
  2757. "Dockerfile": "FROM scratch",
  2758. "Makefile": "all:",
  2759. ".dockerignore": ".*\n",
  2760. })
  2761. defer ctx.Close()
  2762. if err != nil {
  2763. t.Fatal(err)
  2764. }
  2765. if _, err = buildImageFromContext(name, ctx, true); err != nil {
  2766. t.Fatal(err)
  2767. }
  2768. logDone("build - test .dockerignore whole dir with .*")
  2769. }
  2770. func TestBuildLineBreak(t *testing.T) {
  2771. name := "testbuildlinebreak"
  2772. defer deleteImages(name)
  2773. _, err := buildImage(name,
  2774. `FROM busybox
  2775. RUN sh -c 'echo root:testpass \
  2776. > /tmp/passwd'
  2777. RUN mkdir -p /var/run/sshd
  2778. RUN [ "$(cat /tmp/passwd)" = "root:testpass" ]
  2779. RUN [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]`,
  2780. true)
  2781. if err != nil {
  2782. t.Fatal(err)
  2783. }
  2784. logDone("build - line break with \\")
  2785. }
  2786. func TestBuildEOLInLine(t *testing.T) {
  2787. name := "testbuildeolinline"
  2788. defer deleteImages(name)
  2789. _, err := buildImage(name,
  2790. `FROM busybox
  2791. RUN sh -c 'echo root:testpass > /tmp/passwd'
  2792. RUN echo "foo \n bar"; echo "baz"
  2793. RUN mkdir -p /var/run/sshd
  2794. RUN [ "$(cat /tmp/passwd)" = "root:testpass" ]
  2795. RUN [ "$(ls -d /var/run/sshd)" = "/var/run/sshd" ]`,
  2796. true)
  2797. if err != nil {
  2798. t.Fatal(err)
  2799. }
  2800. logDone("build - end of line in dockerfile instruction")
  2801. }
  2802. func TestBuildCommentsShebangs(t *testing.T) {
  2803. name := "testbuildcomments"
  2804. defer deleteImages(name)
  2805. _, err := buildImage(name,
  2806. `FROM busybox
  2807. # This is an ordinary comment.
  2808. RUN { echo '#!/bin/sh'; echo 'echo hello world'; } > /hello.sh
  2809. RUN [ ! -x /hello.sh ]
  2810. # comment with line break \
  2811. RUN chmod +x /hello.sh
  2812. RUN [ -x /hello.sh ]
  2813. RUN [ "$(cat /hello.sh)" = $'#!/bin/sh\necho hello world' ]
  2814. RUN [ "$(/hello.sh)" = "hello world" ]`,
  2815. true)
  2816. if err != nil {
  2817. t.Fatal(err)
  2818. }
  2819. logDone("build - comments and shebangs")
  2820. }
  2821. func TestBuildUsersAndGroups(t *testing.T) {
  2822. name := "testbuildusers"
  2823. defer deleteImages(name)
  2824. _, err := buildImage(name,
  2825. `FROM busybox
  2826. # Make sure our defaults work
  2827. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)" = '0:0/root:root' ]
  2828. # TODO decide if "args.user = strconv.Itoa(syscall.Getuid())" is acceptable behavior for changeUser in sysvinit instead of "return nil" when "USER" isn't specified (so that we get the proper group list even if that is the empty list, even in the default case of not supplying an explicit USER to run as, which implies USER 0)
  2829. USER root
  2830. RUN [ "$(id -G):$(id -Gn)" = '0 10:root wheel' ]
  2831. # Setup dockerio user and group
  2832. RUN echo 'dockerio:x:1001:1001::/bin:/bin/false' >> /etc/passwd
  2833. RUN echo 'dockerio:x:1001:' >> /etc/group
  2834. # Make sure we can switch to our user and all the information is exactly as we expect it to be
  2835. USER dockerio
  2836. RUN id -G
  2837. RUN id -Gn
  2838. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001:dockerio' ]
  2839. # Switch back to root and double check that worked exactly as we might expect it to
  2840. USER root
  2841. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '0:0/root:root/0 10:root wheel' ]
  2842. # Add a "supplementary" group for our dockerio user
  2843. RUN echo 'supplementary:x:1002:dockerio' >> /etc/group
  2844. # ... and then go verify that we get it like we expect
  2845. USER dockerio
  2846. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001 1002:dockerio supplementary' ]
  2847. USER 1001
  2848. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001 1002:dockerio supplementary' ]
  2849. # super test the new "user:group" syntax
  2850. USER dockerio:dockerio
  2851. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001:dockerio' ]
  2852. USER 1001:dockerio
  2853. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001:dockerio' ]
  2854. USER dockerio:1001
  2855. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001:dockerio' ]
  2856. USER 1001:1001
  2857. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1001/dockerio:dockerio/1001:dockerio' ]
  2858. USER dockerio:supplementary
  2859. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1002/dockerio:supplementary/1002:supplementary' ]
  2860. USER dockerio:1002
  2861. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1002/dockerio:supplementary/1002:supplementary' ]
  2862. USER 1001:supplementary
  2863. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1002/dockerio:supplementary/1002:supplementary' ]
  2864. USER 1001:1002
  2865. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1001:1002/dockerio:supplementary/1002:supplementary' ]
  2866. # make sure unknown uid/gid still works properly
  2867. USER 1042:1043
  2868. RUN [ "$(id -u):$(id -g)/$(id -un):$(id -gn)/$(id -G):$(id -Gn)" = '1042:1043/1042:1043/1043:1043' ]`,
  2869. true)
  2870. if err != nil {
  2871. t.Fatal(err)
  2872. }
  2873. logDone("build - users and groups")
  2874. }
  2875. func TestBuildEnvUsage(t *testing.T) {
  2876. name := "testbuildenvusage"
  2877. defer deleteImages(name)
  2878. dockerfile := `FROM busybox
  2879. ENV HOME /root
  2880. ENV PATH $HOME/bin:$PATH
  2881. ENV PATH /tmp:$PATH
  2882. RUN [ "$PATH" = "/tmp:$HOME/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" ]
  2883. ENV FOO /foo/baz
  2884. ENV BAR /bar
  2885. ENV BAZ $BAR
  2886. ENV FOOPATH $PATH:$FOO
  2887. RUN [ "$BAR" = "$BAZ" ]
  2888. RUN [ "$FOOPATH" = "$PATH:/foo/baz" ]
  2889. ENV FROM hello/docker/world
  2890. ENV TO /docker/world/hello
  2891. ADD $FROM $TO
  2892. RUN [ "$(cat $TO)" = "hello" ]
  2893. `
  2894. ctx, err := fakeContext(dockerfile, map[string]string{
  2895. "hello/docker/world": "hello",
  2896. })
  2897. if err != nil {
  2898. t.Fatal(err)
  2899. }
  2900. defer ctx.Close()
  2901. _, err = buildImageFromContext(name, ctx, true)
  2902. if err != nil {
  2903. t.Fatal(err)
  2904. }
  2905. logDone("build - environment variables usage")
  2906. }
  2907. func TestBuildEnvUsage2(t *testing.T) {
  2908. name := "testbuildenvusage2"
  2909. defer deleteImages(name)
  2910. dockerfile := `FROM busybox
  2911. ENV abc=def
  2912. RUN [ "$abc" = "def" ]
  2913. ENV def="hello world"
  2914. RUN [ "$def" = "hello world" ]
  2915. ENV def=hello\ world
  2916. RUN [ "$def" = "hello world" ]
  2917. ENV v1=abc v2="hi there"
  2918. RUN [ "$v1" = "abc" ]
  2919. RUN [ "$v2" = "hi there" ]
  2920. ENV v3='boogie nights' v4="with'quotes too"
  2921. RUN [ "$v3" = "boogie nights" ]
  2922. RUN [ "$v4" = "with'quotes too" ]
  2923. ENV abc=zzz FROM=hello/docker/world
  2924. ENV abc=zzz TO=/docker/world/hello
  2925. ADD $FROM $TO
  2926. RUN [ "$(cat $TO)" = "hello" ]
  2927. ENV abc "zzz"
  2928. RUN [ $abc = \"zzz\" ]
  2929. ENV abc 'yyy'
  2930. RUN [ $abc = \'yyy\' ]
  2931. ENV abc=
  2932. RUN [ "$abc" = "" ]
  2933. `
  2934. ctx, err := fakeContext(dockerfile, map[string]string{
  2935. "hello/docker/world": "hello",
  2936. })
  2937. if err != nil {
  2938. t.Fatal(err)
  2939. }
  2940. _, err = buildImageFromContext(name, ctx, true)
  2941. if err != nil {
  2942. t.Fatal(err)
  2943. }
  2944. logDone("build - environment variables usage2")
  2945. }
  2946. func TestBuildAddScript(t *testing.T) {
  2947. name := "testbuildaddscript"
  2948. defer deleteImages(name)
  2949. dockerfile := `
  2950. FROM busybox
  2951. ADD test /test
  2952. RUN ["chmod","+x","/test"]
  2953. RUN ["/test"]
  2954. RUN [ "$(cat /testfile)" = 'test!' ]`
  2955. ctx, err := fakeContext(dockerfile, map[string]string{
  2956. "test": "#!/bin/sh\necho 'test!' > /testfile",
  2957. })
  2958. if err != nil {
  2959. t.Fatal(err)
  2960. }
  2961. defer ctx.Close()
  2962. _, err = buildImageFromContext(name, ctx, true)
  2963. if err != nil {
  2964. t.Fatal(err)
  2965. }
  2966. logDone("build - add and run script")
  2967. }
  2968. func TestBuildAddTar(t *testing.T) {
  2969. name := "testbuildaddtar"
  2970. defer deleteImages(name)
  2971. ctx := func() *FakeContext {
  2972. dockerfile := `
  2973. FROM busybox
  2974. ADD test.tar /
  2975. RUN cat /test/foo | grep Hi
  2976. ADD test.tar /test.tar
  2977. RUN cat /test.tar/test/foo | grep Hi
  2978. ADD test.tar /unlikely-to-exist
  2979. RUN cat /unlikely-to-exist/test/foo | grep Hi
  2980. ADD test.tar /unlikely-to-exist-trailing-slash/
  2981. RUN cat /unlikely-to-exist-trailing-slash/test/foo | grep Hi
  2982. RUN mkdir /existing-directory
  2983. ADD test.tar /existing-directory
  2984. RUN cat /existing-directory/test/foo | grep Hi
  2985. ADD test.tar /existing-directory-trailing-slash/
  2986. RUN cat /existing-directory-trailing-slash/test/foo | grep Hi`
  2987. tmpDir, err := ioutil.TempDir("", "fake-context")
  2988. testTar, err := os.Create(filepath.Join(tmpDir, "test.tar"))
  2989. if err != nil {
  2990. t.Fatalf("failed to create test.tar archive: %v", err)
  2991. }
  2992. defer testTar.Close()
  2993. tw := tar.NewWriter(testTar)
  2994. if err := tw.WriteHeader(&tar.Header{
  2995. Name: "test/foo",
  2996. Size: 2,
  2997. }); err != nil {
  2998. t.Fatalf("failed to write tar file header: %v", err)
  2999. }
  3000. if _, err := tw.Write([]byte("Hi")); err != nil {
  3001. t.Fatalf("failed to write tar file content: %v", err)
  3002. }
  3003. if err := tw.Close(); err != nil {
  3004. t.Fatalf("failed to close tar archive: %v", err)
  3005. }
  3006. if err := ioutil.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte(dockerfile), 0644); err != nil {
  3007. t.Fatalf("failed to open destination dockerfile: %v", err)
  3008. }
  3009. return &FakeContext{Dir: tmpDir}
  3010. }()
  3011. defer ctx.Close()
  3012. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  3013. t.Fatalf("build failed to complete for TestBuildAddTar: %v", err)
  3014. }
  3015. logDone("build - ADD tar")
  3016. }
  3017. func TestBuildAddTarXz(t *testing.T) {
  3018. name := "testbuildaddtarxz"
  3019. defer deleteImages(name)
  3020. ctx := func() *FakeContext {
  3021. dockerfile := `
  3022. FROM busybox
  3023. ADD test.tar.xz /
  3024. RUN cat /test/foo | grep Hi`
  3025. tmpDir, err := ioutil.TempDir("", "fake-context")
  3026. testTar, err := os.Create(filepath.Join(tmpDir, "test.tar"))
  3027. if err != nil {
  3028. t.Fatalf("failed to create test.tar archive: %v", err)
  3029. }
  3030. defer testTar.Close()
  3031. tw := tar.NewWriter(testTar)
  3032. if err := tw.WriteHeader(&tar.Header{
  3033. Name: "test/foo",
  3034. Size: 2,
  3035. }); err != nil {
  3036. t.Fatalf("failed to write tar file header: %v", err)
  3037. }
  3038. if _, err := tw.Write([]byte("Hi")); err != nil {
  3039. t.Fatalf("failed to write tar file content: %v", err)
  3040. }
  3041. if err := tw.Close(); err != nil {
  3042. t.Fatalf("failed to close tar archive: %v", err)
  3043. }
  3044. xzCompressCmd := exec.Command("xz", "test.tar")
  3045. xzCompressCmd.Dir = tmpDir
  3046. out, _, err := runCommandWithOutput(xzCompressCmd)
  3047. if err != nil {
  3048. t.Fatal(err, out)
  3049. }
  3050. if err := ioutil.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte(dockerfile), 0644); err != nil {
  3051. t.Fatalf("failed to open destination dockerfile: %v", err)
  3052. }
  3053. return &FakeContext{Dir: tmpDir}
  3054. }()
  3055. defer ctx.Close()
  3056. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  3057. t.Fatalf("build failed to complete for TestBuildAddTarXz: %v", err)
  3058. }
  3059. logDone("build - ADD tar.xz")
  3060. }
  3061. func TestBuildAddTarXzGz(t *testing.T) {
  3062. name := "testbuildaddtarxzgz"
  3063. defer deleteImages(name)
  3064. ctx := func() *FakeContext {
  3065. dockerfile := `
  3066. FROM busybox
  3067. ADD test.tar.xz.gz /
  3068. RUN ls /test.tar.xz.gz`
  3069. tmpDir, err := ioutil.TempDir("", "fake-context")
  3070. testTar, err := os.Create(filepath.Join(tmpDir, "test.tar"))
  3071. if err != nil {
  3072. t.Fatalf("failed to create test.tar archive: %v", err)
  3073. }
  3074. defer testTar.Close()
  3075. tw := tar.NewWriter(testTar)
  3076. if err := tw.WriteHeader(&tar.Header{
  3077. Name: "test/foo",
  3078. Size: 2,
  3079. }); err != nil {
  3080. t.Fatalf("failed to write tar file header: %v", err)
  3081. }
  3082. if _, err := tw.Write([]byte("Hi")); err != nil {
  3083. t.Fatalf("failed to write tar file content: %v", err)
  3084. }
  3085. if err := tw.Close(); err != nil {
  3086. t.Fatalf("failed to close tar archive: %v", err)
  3087. }
  3088. xzCompressCmd := exec.Command("xz", "test.tar")
  3089. xzCompressCmd.Dir = tmpDir
  3090. out, _, err := runCommandWithOutput(xzCompressCmd)
  3091. if err != nil {
  3092. t.Fatal(err, out)
  3093. }
  3094. gzipCompressCmd := exec.Command("gzip", "test.tar.xz")
  3095. gzipCompressCmd.Dir = tmpDir
  3096. out, _, err = runCommandWithOutput(gzipCompressCmd)
  3097. if err != nil {
  3098. t.Fatal(err, out)
  3099. }
  3100. if err := ioutil.WriteFile(filepath.Join(tmpDir, "Dockerfile"), []byte(dockerfile), 0644); err != nil {
  3101. t.Fatalf("failed to open destination dockerfile: %v", err)
  3102. }
  3103. return &FakeContext{Dir: tmpDir}
  3104. }()
  3105. defer ctx.Close()
  3106. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  3107. t.Fatalf("build failed to complete for TestBuildAddTarXz: %v", err)
  3108. }
  3109. logDone("build - ADD tar.xz.gz")
  3110. }
  3111. func TestBuildFromGIT(t *testing.T) {
  3112. name := "testbuildfromgit"
  3113. defer deleteImages(name)
  3114. git, err := fakeGIT("repo", map[string]string{
  3115. "Dockerfile": `FROM busybox
  3116. ADD first /first
  3117. RUN [ -f /first ]
  3118. MAINTAINER docker`,
  3119. "first": "test git data",
  3120. })
  3121. if err != nil {
  3122. t.Fatal(err)
  3123. }
  3124. defer git.Close()
  3125. _, err = buildImageFromPath(name, git.RepoURL, true)
  3126. if err != nil {
  3127. t.Fatal(err)
  3128. }
  3129. res, err := inspectField(name, "Author")
  3130. if err != nil {
  3131. t.Fatal(err)
  3132. }
  3133. if res != "docker" {
  3134. t.Fatalf("Maintainer should be docker, got %s", res)
  3135. }
  3136. logDone("build - build from GIT")
  3137. }
  3138. func TestBuildCleanupCmdOnEntrypoint(t *testing.T) {
  3139. name := "testbuildcmdcleanuponentrypoint"
  3140. defer deleteImages(name)
  3141. if _, err := buildImage(name,
  3142. `FROM scratch
  3143. CMD ["test"]
  3144. ENTRYPOINT ["echo"]`,
  3145. true); err != nil {
  3146. t.Fatal(err)
  3147. }
  3148. if _, err := buildImage(name,
  3149. fmt.Sprintf(`FROM %s
  3150. ENTRYPOINT ["cat"]`, name),
  3151. true); err != nil {
  3152. t.Fatal(err)
  3153. }
  3154. res, err := inspectField(name, "Config.Cmd")
  3155. if err != nil {
  3156. t.Fatal(err)
  3157. }
  3158. if expected := "<no value>"; res != expected {
  3159. t.Fatalf("Cmd %s, expected %s", res, expected)
  3160. }
  3161. res, err = inspectField(name, "Config.Entrypoint")
  3162. if err != nil {
  3163. t.Fatal(err)
  3164. }
  3165. if expected := "[cat]"; res != expected {
  3166. t.Fatalf("Entrypoint %s, expected %s", res, expected)
  3167. }
  3168. logDone("build - cleanup cmd on ENTRYPOINT")
  3169. }
  3170. func TestBuildClearCmd(t *testing.T) {
  3171. name := "testbuildclearcmd"
  3172. defer deleteImages(name)
  3173. _, err := buildImage(name,
  3174. `From scratch
  3175. ENTRYPOINT ["/bin/bash"]
  3176. CMD []`,
  3177. true)
  3178. if err != nil {
  3179. t.Fatal(err)
  3180. }
  3181. res, err := inspectFieldJSON(name, "Config.Cmd")
  3182. if err != nil {
  3183. t.Fatal(err)
  3184. }
  3185. if res != "[]" {
  3186. t.Fatalf("Cmd %s, expected %s", res, "[]")
  3187. }
  3188. logDone("build - clearcmd")
  3189. }
  3190. func TestBuildEmptyCmd(t *testing.T) {
  3191. name := "testbuildemptycmd"
  3192. defer deleteImages(name)
  3193. if _, err := buildImage(name, "FROM scratch\nMAINTAINER quux\n", true); err != nil {
  3194. t.Fatal(err)
  3195. }
  3196. res, err := inspectFieldJSON(name, "Config.Cmd")
  3197. if err != nil {
  3198. t.Fatal(err)
  3199. }
  3200. if res != "null" {
  3201. t.Fatalf("Cmd %s, expected %s", res, "null")
  3202. }
  3203. logDone("build - empty cmd")
  3204. }
  3205. func TestBuildOnBuildOutput(t *testing.T) {
  3206. name := "testbuildonbuildparent"
  3207. defer deleteImages(name)
  3208. if _, err := buildImage(name, "FROM busybox\nONBUILD RUN echo foo\n", true); err != nil {
  3209. t.Fatal(err)
  3210. }
  3211. childname := "testbuildonbuildchild"
  3212. defer deleteImages(childname)
  3213. _, out, err := buildImageWithOut(name, "FROM "+name+"\nMAINTAINER quux\n", true)
  3214. if err != nil {
  3215. t.Fatal(err)
  3216. }
  3217. if !strings.Contains(out, "Trigger 0, RUN echo foo") {
  3218. t.Fatal("failed to find the ONBUILD output", out)
  3219. }
  3220. logDone("build - onbuild output")
  3221. }
  3222. func TestBuildInvalidTag(t *testing.T) {
  3223. name := "abcd:" + makeRandomString(200)
  3224. defer deleteImages(name)
  3225. _, out, err := buildImageWithOut(name, "FROM scratch\nMAINTAINER quux\n", true)
  3226. // if the error doesnt check for illegal tag name, or the image is built
  3227. // then this should fail
  3228. if !strings.Contains(out, "Illegal tag name") || strings.Contains(out, "Sending build context to Docker daemon") {
  3229. t.Fatalf("failed to stop before building. Error: %s, Output: %s", err, out)
  3230. }
  3231. logDone("build - invalid tag")
  3232. }
  3233. func TestBuildCmdShDashC(t *testing.T) {
  3234. name := "testbuildcmdshc"
  3235. defer deleteImages(name)
  3236. if _, err := buildImage(name, "FROM busybox\nCMD echo cmd\n", true); err != nil {
  3237. t.Fatal(err)
  3238. }
  3239. res, err := inspectFieldJSON(name, "Config.Cmd")
  3240. if err != nil {
  3241. t.Fatal(err, res)
  3242. }
  3243. expected := `["/bin/sh","-c","echo cmd"]`
  3244. if res != expected {
  3245. t.Fatalf("Expected value %s not in Config.Cmd: %s", expected, res)
  3246. }
  3247. logDone("build - cmd should have sh -c for non-json")
  3248. }
  3249. func TestBuildCmdJSONNoShDashC(t *testing.T) {
  3250. name := "testbuildcmdjson"
  3251. defer deleteImages(name)
  3252. if _, err := buildImage(name, "FROM busybox\nCMD [\"echo\", \"cmd\"]", true); err != nil {
  3253. t.Fatal(err)
  3254. }
  3255. res, err := inspectFieldJSON(name, "Config.Cmd")
  3256. if err != nil {
  3257. t.Fatal(err, res)
  3258. }
  3259. expected := `["echo","cmd"]`
  3260. if res != expected {
  3261. t.Fatalf("Expected value %s not in Config.Cmd: %s", expected, res)
  3262. }
  3263. logDone("build - cmd should not have /bin/sh -c for json")
  3264. }
  3265. func TestBuildIgnoreInvalidInstruction(t *testing.T) {
  3266. name := "testbuildignoreinvalidinstruction"
  3267. defer deleteImages(name)
  3268. out, _, err := buildImageWithOut(name, "FROM busybox\nfoo bar", true)
  3269. if err != nil {
  3270. t.Fatal(err, out)
  3271. }
  3272. logDone("build - ignore invalid Dockerfile instruction")
  3273. }
  3274. func TestBuildEntrypointInheritance(t *testing.T) {
  3275. defer deleteImages("parent", "child")
  3276. defer deleteAllContainers()
  3277. if _, err := buildImage("parent", `
  3278. FROM busybox
  3279. ENTRYPOINT exit 130
  3280. `, true); err != nil {
  3281. t.Fatal(err)
  3282. }
  3283. status, _ := runCommand(exec.Command(dockerBinary, "run", "parent"))
  3284. if status != 130 {
  3285. t.Fatalf("expected exit code 130 but received %d", status)
  3286. }
  3287. if _, err := buildImage("child", `
  3288. FROM parent
  3289. ENTRYPOINT exit 5
  3290. `, true); err != nil {
  3291. t.Fatal(err)
  3292. }
  3293. status, _ = runCommand(exec.Command(dockerBinary, "run", "child"))
  3294. if status != 5 {
  3295. t.Fatalf("expected exit code 5 but received %d", status)
  3296. }
  3297. logDone("build - clear entrypoint")
  3298. }
  3299. func TestBuildEntrypointInheritanceInspect(t *testing.T) {
  3300. var (
  3301. name = "testbuildepinherit"
  3302. name2 = "testbuildepinherit2"
  3303. expected = `["/bin/sh","-c","echo quux"]`
  3304. )
  3305. defer deleteImages(name, name2)
  3306. defer deleteAllContainers()
  3307. if _, err := buildImage(name, "FROM busybox\nENTRYPOINT /foo/bar", true); err != nil {
  3308. t.Fatal(err)
  3309. }
  3310. if _, err := buildImage(name2, fmt.Sprintf("FROM %s\nENTRYPOINT echo quux", name), true); err != nil {
  3311. t.Fatal(err)
  3312. }
  3313. res, err := inspectFieldJSON(name2, "Config.Entrypoint")
  3314. if err != nil {
  3315. t.Fatal(err, res)
  3316. }
  3317. if res != expected {
  3318. t.Fatalf("Expected value %s not in Config.Entrypoint: %s", expected, res)
  3319. }
  3320. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "-t", name2))
  3321. if err != nil {
  3322. t.Fatal(err, out)
  3323. }
  3324. expected = "quux"
  3325. if strings.TrimSpace(out) != expected {
  3326. t.Fatalf("Expected output is %s, got %s", expected, out)
  3327. }
  3328. logDone("build - entrypoint override inheritance properly")
  3329. }
  3330. func TestBuildRunShEntrypoint(t *testing.T) {
  3331. name := "testbuildentrypoint"
  3332. defer deleteImages(name)
  3333. _, err := buildImage(name,
  3334. `FROM busybox
  3335. ENTRYPOINT /bin/echo`,
  3336. true)
  3337. if err != nil {
  3338. t.Fatal(err)
  3339. }
  3340. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", name))
  3341. if err != nil {
  3342. t.Fatal(err, out)
  3343. }
  3344. logDone("build - entrypoint with /bin/echo running successfully")
  3345. }
  3346. func TestBuildExoticShellInterpolation(t *testing.T) {
  3347. name := "testbuildexoticshellinterpolation"
  3348. defer deleteImages(name)
  3349. _, err := buildImage(name, `
  3350. FROM busybox
  3351. ENV SOME_VAR a.b.c
  3352. RUN [ "$SOME_VAR" = 'a.b.c' ]
  3353. RUN [ "${SOME_VAR}" = 'a.b.c' ]
  3354. RUN [ "${SOME_VAR%.*}" = 'a.b' ]
  3355. RUN [ "${SOME_VAR%%.*}" = 'a' ]
  3356. RUN [ "${SOME_VAR#*.}" = 'b.c' ]
  3357. RUN [ "${SOME_VAR##*.}" = 'c' ]
  3358. RUN [ "${SOME_VAR/c/d}" = 'a.b.d' ]
  3359. RUN [ "${#SOME_VAR}" = '5' ]
  3360. RUN [ "${SOME_UNSET_VAR:-$SOME_VAR}" = 'a.b.c' ]
  3361. RUN [ "${SOME_VAR:+Version: ${SOME_VAR}}" = 'Version: a.b.c' ]
  3362. RUN [ "${SOME_UNSET_VAR:+${SOME_VAR}}" = '' ]
  3363. RUN [ "${SOME_UNSET_VAR:-${SOME_VAR:-d.e.f}}" = 'a.b.c' ]
  3364. `, false)
  3365. if err != nil {
  3366. t.Fatal(err)
  3367. }
  3368. logDone("build - exotic shell interpolation")
  3369. }
  3370. func TestBuildVerifySingleQuoteFails(t *testing.T) {
  3371. // This testcase is supposed to generate an error because the
  3372. // JSON array we're passing in on the CMD uses single quotes instead
  3373. // of double quotes (per the JSON spec). This means we interpret it
  3374. // as a "string" insead of "JSON array" and pass it on to "sh -c" and
  3375. // it should barf on it.
  3376. name := "testbuildsinglequotefails"
  3377. defer deleteImages(name)
  3378. defer deleteAllContainers()
  3379. _, err := buildImage(name,
  3380. `FROM busybox
  3381. CMD [ '/bin/sh', '-c', 'echo hi' ]`,
  3382. true)
  3383. _, _, err = runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", name))
  3384. if err == nil {
  3385. t.Fatal("The image was not supposed to be able to run")
  3386. }
  3387. logDone("build - verify single quotes fail")
  3388. }
  3389. func TestBuildVerboseOut(t *testing.T) {
  3390. name := "testbuildverboseout"
  3391. defer deleteImages(name)
  3392. _, out, err := buildImageWithOut(name,
  3393. `FROM busybox
  3394. RUN echo 123`,
  3395. false)
  3396. if err != nil {
  3397. t.Fatal(err)
  3398. }
  3399. if !strings.Contains(out, "\n123\n") {
  3400. t.Fatalf("Output should contain %q: %q", "123", out)
  3401. }
  3402. logDone("build - verbose output from commands")
  3403. }
  3404. func TestBuildWithTabs(t *testing.T) {
  3405. name := "testbuildwithtabs"
  3406. defer deleteImages(name)
  3407. _, err := buildImage(name,
  3408. "FROM busybox\nRUN echo\tone\t\ttwo", true)
  3409. if err != nil {
  3410. t.Fatal(err)
  3411. }
  3412. res, err := inspectFieldJSON(name, "ContainerConfig.Cmd")
  3413. if err != nil {
  3414. t.Fatal(err)
  3415. }
  3416. expected := "[\"/bin/sh\",\"-c\",\"echo\\u0009one\\u0009\\u0009two\"]"
  3417. if res != expected {
  3418. t.Fatalf("Missing tabs.\nGot:%s\nExp:%s", res, expected)
  3419. }
  3420. logDone("build - with tabs")
  3421. }
  3422. func TestBuildStderr(t *testing.T) {
  3423. // This test just makes sure that no non-error output goes
  3424. // to stderr
  3425. name := "testbuildstderr"
  3426. defer deleteImages(name)
  3427. _, _, stderr, err := buildImageWithStdoutStderr(name,
  3428. "FROM busybox\nRUN echo one", true)
  3429. if err != nil {
  3430. t.Fatal(err)
  3431. }
  3432. if stderr != "" {
  3433. t.Fatalf("Stderr should have been empty, instead its: %q", stderr)
  3434. }
  3435. logDone("build - testing stderr")
  3436. }
  3437. func TestBuildChownSingleFile(t *testing.T) {
  3438. name := "testbuildchownsinglefile"
  3439. defer deleteImages(name)
  3440. ctx, err := fakeContext(`
  3441. FROM busybox
  3442. COPY test /
  3443. RUN ls -l /test
  3444. RUN [ $(ls -l /test | awk '{print $3":"$4}') = 'root:root' ]
  3445. `, map[string]string{
  3446. "test": "test",
  3447. })
  3448. if err != nil {
  3449. t.Fatal(err)
  3450. }
  3451. defer ctx.Close()
  3452. if err := os.Chown(filepath.Join(ctx.Dir, "test"), 4242, 4242); err != nil {
  3453. t.Fatal(err)
  3454. }
  3455. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  3456. t.Fatal(err)
  3457. }
  3458. logDone("build - change permission on single file")
  3459. }
  3460. func TestBuildSymlinkBreakout(t *testing.T) {
  3461. name := "testbuildsymlinkbreakout"
  3462. tmpdir, err := ioutil.TempDir("", name)
  3463. if err != nil {
  3464. t.Fatal(err)
  3465. }
  3466. defer os.RemoveAll(tmpdir)
  3467. ctx := filepath.Join(tmpdir, "context")
  3468. if err := os.MkdirAll(ctx, 0755); err != nil {
  3469. t.Fatal(err)
  3470. }
  3471. if err := ioutil.WriteFile(filepath.Join(ctx, "Dockerfile"), []byte(`
  3472. from busybox
  3473. add symlink.tar /
  3474. add inject /symlink/
  3475. `), 0644); err != nil {
  3476. t.Fatal(err)
  3477. }
  3478. inject := filepath.Join(ctx, "inject")
  3479. if err := ioutil.WriteFile(inject, nil, 0644); err != nil {
  3480. t.Fatal(err)
  3481. }
  3482. f, err := os.Create(filepath.Join(ctx, "symlink.tar"))
  3483. if err != nil {
  3484. t.Fatal(err)
  3485. }
  3486. w := tar.NewWriter(f)
  3487. w.WriteHeader(&tar.Header{
  3488. Name: "symlink2",
  3489. Typeflag: tar.TypeSymlink,
  3490. Linkname: "/../../../../../../../../../../../../../../",
  3491. Uid: os.Getuid(),
  3492. Gid: os.Getgid(),
  3493. })
  3494. w.WriteHeader(&tar.Header{
  3495. Name: "symlink",
  3496. Typeflag: tar.TypeSymlink,
  3497. Linkname: filepath.Join("symlink2", tmpdir),
  3498. Uid: os.Getuid(),
  3499. Gid: os.Getgid(),
  3500. })
  3501. w.Close()
  3502. f.Close()
  3503. if _, err := buildImageFromContext(name, &FakeContext{Dir: ctx}, false); err != nil {
  3504. t.Fatal(err)
  3505. }
  3506. if _, err := os.Lstat(filepath.Join(tmpdir, "inject")); err == nil {
  3507. t.Fatal("symlink breakout - inject")
  3508. } else if !os.IsNotExist(err) {
  3509. t.Fatalf("unexpected error: %v", err)
  3510. }
  3511. logDone("build - symlink breakout")
  3512. }
  3513. func TestBuildXZHost(t *testing.T) {
  3514. name := "testbuildxzhost"
  3515. defer deleteImages(name)
  3516. ctx, err := fakeContext(`
  3517. FROM busybox
  3518. ADD xz /usr/local/sbin/
  3519. RUN chmod 755 /usr/local/sbin/xz
  3520. ADD test.xz /
  3521. RUN [ ! -e /injected ]`,
  3522. map[string]string{
  3523. "test.xz": "\xfd\x37\x7a\x58\x5a\x00\x00\x04\xe6\xd6\xb4\x46\x02\x00" +
  3524. "\x21\x01\x16\x00\x00\x00\x74\x2f\xe5\xa3\x01\x00\x3f\xfd" +
  3525. "\x37\x7a\x58\x5a\x00\x00\x04\xe6\xd6\xb4\x46\x02\x00\x21",
  3526. "xz": "#!/bin/sh\ntouch /injected",
  3527. })
  3528. if err != nil {
  3529. t.Fatal(err)
  3530. }
  3531. defer ctx.Close()
  3532. if _, err := buildImageFromContext(name, ctx, true); err != nil {
  3533. t.Fatal(err)
  3534. }
  3535. logDone("build - xz host is being used")
  3536. }
  3537. func TestBuildVolumesRetainContents(t *testing.T) {
  3538. var (
  3539. name = "testbuildvolumescontent"
  3540. expected = "some text"
  3541. )
  3542. defer deleteImages(name)
  3543. ctx, err := fakeContext(`
  3544. FROM busybox
  3545. COPY content /foo/file
  3546. VOLUME /foo
  3547. CMD cat /foo/file`,
  3548. map[string]string{
  3549. "content": expected,
  3550. })
  3551. if err != nil {
  3552. t.Fatal(err)
  3553. }
  3554. defer ctx.Close()
  3555. if _, err := buildImageFromContext(name, ctx, false); err != nil {
  3556. t.Fatal(err)
  3557. }
  3558. out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "run", "--rm", name))
  3559. if err != nil {
  3560. t.Fatal(err)
  3561. }
  3562. if out != expected {
  3563. t.Fatalf("expected file contents for /foo/file to be %q but received %q", expected, out)
  3564. }
  3565. logDone("build - volumes retain contents in build")
  3566. }