docker_cli_build_test.go 85 KB

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