docker_cli_by_digest_test.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535
  1. package main
  2. import (
  3. "fmt"
  4. "os/exec"
  5. "regexp"
  6. "strings"
  7. "testing"
  8. "github.com/docker/docker/utils"
  9. )
  10. var (
  11. repoName = fmt.Sprintf("%v/dockercli/busybox-by-dgst", privateRegistryURL)
  12. digestRegex = regexp.MustCompile("Digest: ([^\n]+)")
  13. )
  14. func setupImage() (string, error) {
  15. return setupImageWithTag("latest")
  16. }
  17. func setupImageWithTag(tag string) (string, error) {
  18. containerName := "busyboxbydigest"
  19. c := exec.Command(dockerBinary, "run", "-d", "-e", "digest=1", "--name", containerName, "busybox")
  20. if _, err := runCommand(c); err != nil {
  21. return "", err
  22. }
  23. // tag the image to upload it to the private registry
  24. repoAndTag := utils.ImageReference(repoName, tag)
  25. c = exec.Command(dockerBinary, "commit", containerName, repoAndTag)
  26. if out, _, err := runCommandWithOutput(c); err != nil {
  27. return "", fmt.Errorf("image tagging failed: %s, %v", out, err)
  28. }
  29. defer deleteImages(repoAndTag)
  30. // delete the container as we don't need it any more
  31. if err := deleteContainer(containerName); err != nil {
  32. return "", err
  33. }
  34. // push the image
  35. c = exec.Command(dockerBinary, "push", repoAndTag)
  36. out, _, err := runCommandWithOutput(c)
  37. if err != nil {
  38. return "", fmt.Errorf("pushing the image to the private registry has failed: %s, %v", out, err)
  39. }
  40. // delete our local repo that we previously tagged
  41. c = exec.Command(dockerBinary, "rmi", repoAndTag)
  42. if out, _, err := runCommandWithOutput(c); err != nil {
  43. return "", fmt.Errorf("error deleting images prior to real test: %s, %v", out, err)
  44. }
  45. // the push output includes "Digest: <digest>", so find that
  46. matches := digestRegex.FindStringSubmatch(out)
  47. if len(matches) != 2 {
  48. return "", fmt.Errorf("unable to parse digest from push output: %s", out)
  49. }
  50. pushDigest := matches[1]
  51. return pushDigest, nil
  52. }
  53. func TestPullByTagDisplaysDigest(t *testing.T) {
  54. defer setupRegistry(t)()
  55. pushDigest, err := setupImage()
  56. if err != nil {
  57. t.Fatalf("error setting up image: %v", err)
  58. }
  59. // pull from the registry using the tag
  60. c := exec.Command(dockerBinary, "pull", repoName)
  61. out, _, err := runCommandWithOutput(c)
  62. if err != nil {
  63. t.Fatalf("error pulling by tag: %s, %v", out, err)
  64. }
  65. defer deleteImages(repoName)
  66. // the pull output includes "Digest: <digest>", so find that
  67. matches := digestRegex.FindStringSubmatch(out)
  68. if len(matches) != 2 {
  69. t.Fatalf("unable to parse digest from pull output: %s", out)
  70. }
  71. pullDigest := matches[1]
  72. // make sure the pushed and pull digests match
  73. if pushDigest != pullDigest {
  74. t.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
  75. }
  76. logDone("by_digest - pull by tag displays digest")
  77. }
  78. func TestPullByDigest(t *testing.T) {
  79. defer setupRegistry(t)()
  80. pushDigest, err := setupImage()
  81. if err != nil {
  82. t.Fatalf("error setting up image: %v", err)
  83. }
  84. // pull from the registry using the <name>@<digest> reference
  85. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  86. c := exec.Command(dockerBinary, "pull", imageReference)
  87. out, _, err := runCommandWithOutput(c)
  88. if err != nil {
  89. t.Fatalf("error pulling by digest: %s, %v", out, err)
  90. }
  91. defer deleteImages(imageReference)
  92. // the pull output includes "Digest: <digest>", so find that
  93. matches := digestRegex.FindStringSubmatch(out)
  94. if len(matches) != 2 {
  95. t.Fatalf("unable to parse digest from pull output: %s", out)
  96. }
  97. pullDigest := matches[1]
  98. // make sure the pushed and pull digests match
  99. if pushDigest != pullDigest {
  100. t.Fatalf("push digest %q didn't match pull digest %q", pushDigest, pullDigest)
  101. }
  102. logDone("by_digest - pull by digest")
  103. }
  104. func TestCreateByDigest(t *testing.T) {
  105. defer setupRegistry(t)()
  106. pushDigest, err := setupImage()
  107. if err != nil {
  108. t.Fatalf("error setting up image: %v", err)
  109. }
  110. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  111. containerName := "createByDigest"
  112. c := exec.Command(dockerBinary, "create", "--name", containerName, imageReference)
  113. out, _, err := runCommandWithOutput(c)
  114. if err != nil {
  115. t.Fatalf("error creating by digest: %s, %v", out, err)
  116. }
  117. defer deleteContainer(containerName)
  118. res, err := inspectField(containerName, "Config.Image")
  119. if err != nil {
  120. t.Fatalf("failed to get Config.Image: %s, %v", out, err)
  121. }
  122. if res != imageReference {
  123. t.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
  124. }
  125. logDone("by_digest - create by digest")
  126. }
  127. func TestRunByDigest(t *testing.T) {
  128. defer setupRegistry(t)()
  129. pushDigest, err := setupImage()
  130. if err != nil {
  131. t.Fatalf("error setting up image: %v", err)
  132. }
  133. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  134. containerName := "runByDigest"
  135. c := exec.Command(dockerBinary, "run", "--name", containerName, imageReference, "sh", "-c", "echo found=$digest")
  136. out, _, err := runCommandWithOutput(c)
  137. if err != nil {
  138. t.Fatalf("error run by digest: %s, %v", out, err)
  139. }
  140. defer deleteContainer(containerName)
  141. foundRegex := regexp.MustCompile("found=([^\n]+)")
  142. matches := foundRegex.FindStringSubmatch(out)
  143. if len(matches) != 2 {
  144. t.Fatalf("error locating expected 'found=1' output: %s", out)
  145. }
  146. if matches[1] != "1" {
  147. t.Fatalf("Expected %q, got %q", "1", matches[1])
  148. }
  149. res, err := inspectField(containerName, "Config.Image")
  150. if err != nil {
  151. t.Fatalf("failed to get Config.Image: %s, %v", out, err)
  152. }
  153. if res != imageReference {
  154. t.Fatalf("unexpected Config.Image: %s (expected %s)", res, imageReference)
  155. }
  156. logDone("by_digest - run by digest")
  157. }
  158. func TestRemoveImageByDigest(t *testing.T) {
  159. defer setupRegistry(t)()
  160. digest, err := setupImage()
  161. if err != nil {
  162. t.Fatalf("error setting up image: %v", err)
  163. }
  164. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  165. // pull from the registry using the <name>@<digest> reference
  166. c := exec.Command(dockerBinary, "pull", imageReference)
  167. out, _, err := runCommandWithOutput(c)
  168. if err != nil {
  169. t.Fatalf("error pulling by digest: %s, %v", out, err)
  170. }
  171. // make sure inspect runs ok
  172. if _, err := inspectField(imageReference, "Id"); err != nil {
  173. t.Fatalf("failed to inspect image: %v", err)
  174. }
  175. // do the delete
  176. if err := deleteImages(imageReference); err != nil {
  177. t.Fatalf("unexpected error deleting image: %v", err)
  178. }
  179. // try to inspect again - it should error this time
  180. if _, err := inspectField(imageReference, "Id"); err == nil {
  181. t.Fatalf("unexpected nil err trying to inspect what should be a non-existent image")
  182. } else if !strings.Contains(err.Error(), "No such image") {
  183. t.Fatalf("expected 'No such image' output, got %v", err)
  184. }
  185. logDone("by_digest - remove image by digest")
  186. }
  187. func TestBuildByDigest(t *testing.T) {
  188. defer setupRegistry(t)()
  189. digest, err := setupImage()
  190. if err != nil {
  191. t.Fatalf("error setting up image: %v", err)
  192. }
  193. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  194. // pull from the registry using the <name>@<digest> reference
  195. c := exec.Command(dockerBinary, "pull", imageReference)
  196. out, _, err := runCommandWithOutput(c)
  197. if err != nil {
  198. t.Fatalf("error pulling by digest: %s, %v", out, err)
  199. }
  200. // get the image id
  201. imageID, err := inspectField(imageReference, "Id")
  202. if err != nil {
  203. t.Fatalf("error getting image id: %v", err)
  204. }
  205. // do the build
  206. name := "buildbydigest"
  207. defer deleteImages(name)
  208. _, err = buildImage(name, fmt.Sprintf(
  209. `FROM %s
  210. CMD ["/bin/echo", "Hello World"]`, imageReference),
  211. true)
  212. if err != nil {
  213. t.Fatal(err)
  214. }
  215. // get the build's image id
  216. res, err := inspectField(name, "Config.Image")
  217. if err != nil {
  218. t.Fatal(err)
  219. }
  220. // make sure they match
  221. if res != imageID {
  222. t.Fatalf("Image %s, expected %s", res, imageID)
  223. }
  224. logDone("by_digest - build by digest")
  225. }
  226. func TestTagByDigest(t *testing.T) {
  227. defer setupRegistry(t)()
  228. digest, err := setupImage()
  229. if err != nil {
  230. t.Fatalf("error setting up image: %v", err)
  231. }
  232. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  233. // pull from the registry using the <name>@<digest> reference
  234. c := exec.Command(dockerBinary, "pull", imageReference)
  235. out, _, err := runCommandWithOutput(c)
  236. if err != nil {
  237. t.Fatalf("error pulling by digest: %s, %v", out, err)
  238. }
  239. // tag it
  240. tag := "tagbydigest"
  241. c = exec.Command(dockerBinary, "tag", imageReference, tag)
  242. if _, err := runCommand(c); err != nil {
  243. t.Fatalf("unexpected error tagging: %v", err)
  244. }
  245. expectedID, err := inspectField(imageReference, "Id")
  246. if err != nil {
  247. t.Fatalf("error getting original image id: %v", err)
  248. }
  249. tagID, err := inspectField(tag, "Id")
  250. if err != nil {
  251. t.Fatalf("error getting tagged image id: %v", err)
  252. }
  253. if tagID != expectedID {
  254. t.Fatalf("expected image id %q, got %q", expectedID, tagID)
  255. }
  256. logDone("by_digest - tag by digest")
  257. }
  258. func TestListImagesWithoutDigests(t *testing.T) {
  259. defer setupRegistry(t)()
  260. digest, err := setupImage()
  261. if err != nil {
  262. t.Fatalf("error setting up image: %v", err)
  263. }
  264. imageReference := fmt.Sprintf("%s@%s", repoName, digest)
  265. // pull from the registry using the <name>@<digest> reference
  266. c := exec.Command(dockerBinary, "pull", imageReference)
  267. out, _, err := runCommandWithOutput(c)
  268. if err != nil {
  269. t.Fatalf("error pulling by digest: %s, %v", out, err)
  270. }
  271. c = exec.Command(dockerBinary, "images")
  272. out, _, err = runCommandWithOutput(c)
  273. if err != nil {
  274. t.Fatalf("error listing images: %s, %v", out, err)
  275. }
  276. if strings.Contains(out, "DIGEST") {
  277. t.Fatalf("list output should not have contained DIGEST header: %s", out)
  278. }
  279. logDone("by_digest - list images - digest header not displayed by default")
  280. }
  281. func TestListImagesWithDigests(t *testing.T) {
  282. defer setupRegistry(t)()
  283. defer deleteImages(repoName+":tag1", repoName+":tag2")
  284. // setup image1
  285. digest1, err := setupImageWithTag("tag1")
  286. if err != nil {
  287. t.Fatalf("error setting up image: %v", err)
  288. }
  289. imageReference1 := fmt.Sprintf("%s@%s", repoName, digest1)
  290. defer deleteImages(imageReference1)
  291. t.Logf("imageReference1 = %s", imageReference1)
  292. // pull image1 by digest
  293. c := exec.Command(dockerBinary, "pull", imageReference1)
  294. out, _, err := runCommandWithOutput(c)
  295. if err != nil {
  296. t.Fatalf("error pulling by digest: %s, %v", out, err)
  297. }
  298. // list images
  299. c = exec.Command(dockerBinary, "images", "--digests")
  300. out, _, err = runCommandWithOutput(c)
  301. if err != nil {
  302. t.Fatalf("error listing images: %s, %v", out, err)
  303. }
  304. // make sure repo shown, tag=<none>, digest = $digest1
  305. re1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1 + `\s`)
  306. if !re1.MatchString(out) {
  307. t.Fatalf("expected %q: %s", re1.String(), out)
  308. }
  309. // setup image2
  310. digest2, err := setupImageWithTag("tag2")
  311. if err != nil {
  312. t.Fatalf("error setting up image: %v", err)
  313. }
  314. imageReference2 := fmt.Sprintf("%s@%s", repoName, digest2)
  315. defer deleteImages(imageReference2)
  316. t.Logf("imageReference2 = %s", imageReference2)
  317. // pull image1 by digest
  318. c = exec.Command(dockerBinary, "pull", imageReference1)
  319. out, _, err = runCommandWithOutput(c)
  320. if err != nil {
  321. t.Fatalf("error pulling by digest: %s, %v", out, err)
  322. }
  323. // pull image2 by digest
  324. c = exec.Command(dockerBinary, "pull", imageReference2)
  325. out, _, err = runCommandWithOutput(c)
  326. if err != nil {
  327. t.Fatalf("error pulling by digest: %s, %v", out, err)
  328. }
  329. // list images
  330. c = exec.Command(dockerBinary, "images", "--digests")
  331. out, _, err = runCommandWithOutput(c)
  332. if err != nil {
  333. t.Fatalf("error listing images: %s, %v", out, err)
  334. }
  335. // make sure repo shown, tag=<none>, digest = $digest1
  336. if !re1.MatchString(out) {
  337. t.Fatalf("expected %q: %s", re1.String(), out)
  338. }
  339. // make sure repo shown, tag=<none>, digest = $digest2
  340. re2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2 + `\s`)
  341. if !re2.MatchString(out) {
  342. t.Fatalf("expected %q: %s", re2.String(), out)
  343. }
  344. // pull tag1
  345. c = exec.Command(dockerBinary, "pull", repoName+":tag1")
  346. out, _, err = runCommandWithOutput(c)
  347. if err != nil {
  348. t.Fatalf("error pulling tag1: %s, %v", out, err)
  349. }
  350. // list images
  351. c = exec.Command(dockerBinary, "images", "--digests")
  352. out, _, err = runCommandWithOutput(c)
  353. if err != nil {
  354. t.Fatalf("error listing images: %s, %v", out, err)
  355. }
  356. // make sure image 1 has repo, tag, <none> AND repo, <none>, digest
  357. reWithTag1 := regexp.MustCompile(`\s*` + repoName + `\s*tag1\s*<none>\s`)
  358. reWithDigest1 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest1 + `\s`)
  359. if !reWithTag1.MatchString(out) {
  360. t.Fatalf("expected %q: %s", reWithTag1.String(), out)
  361. }
  362. if !reWithDigest1.MatchString(out) {
  363. t.Fatalf("expected %q: %s", reWithDigest1.String(), out)
  364. }
  365. // make sure image 2 has repo, <none>, digest
  366. if !re2.MatchString(out) {
  367. t.Fatalf("expected %q: %s", re2.String(), out)
  368. }
  369. // pull tag 2
  370. c = exec.Command(dockerBinary, "pull", repoName+":tag2")
  371. out, _, err = runCommandWithOutput(c)
  372. if err != nil {
  373. t.Fatalf("error pulling tag2: %s, %v", out, err)
  374. }
  375. // list images
  376. c = exec.Command(dockerBinary, "images", "--digests")
  377. out, _, err = runCommandWithOutput(c)
  378. if err != nil {
  379. t.Fatalf("error listing images: %s, %v", out, err)
  380. }
  381. // make sure image 1 has repo, tag, digest
  382. if !reWithTag1.MatchString(out) {
  383. t.Fatalf("expected %q: %s", re1.String(), out)
  384. }
  385. // make sure image 2 has repo, tag, digest
  386. reWithTag2 := regexp.MustCompile(`\s*` + repoName + `\s*tag2\s*<none>\s`)
  387. reWithDigest2 := regexp.MustCompile(`\s*` + repoName + `\s*<none>\s*` + digest2 + `\s`)
  388. if !reWithTag2.MatchString(out) {
  389. t.Fatalf("expected %q: %s", reWithTag2.String(), out)
  390. }
  391. if !reWithDigest2.MatchString(out) {
  392. t.Fatalf("expected %q: %s", reWithDigest2.String(), out)
  393. }
  394. // list images
  395. c = exec.Command(dockerBinary, "images", "--digests")
  396. out, _, err = runCommandWithOutput(c)
  397. if err != nil {
  398. t.Fatalf("error listing images: %s, %v", out, err)
  399. }
  400. // make sure image 1 has repo, tag, digest
  401. if !reWithTag1.MatchString(out) {
  402. t.Fatalf("expected %q: %s", re1.String(), out)
  403. }
  404. // make sure image 2 has repo, tag, digest
  405. if !reWithTag2.MatchString(out) {
  406. t.Fatalf("expected %q: %s", re2.String(), out)
  407. }
  408. // make sure busybox has tag, but not digest
  409. busyboxRe := regexp.MustCompile(`\s*busybox\s*latest\s*<none>\s`)
  410. if !busyboxRe.MatchString(out) {
  411. t.Fatalf("expected %q: %s", busyboxRe.String(), out)
  412. }
  413. logDone("by_digest - list images with digests")
  414. }
  415. func TestDeleteImageByIDOnlyPulledByDigest(t *testing.T) {
  416. defer setupRegistry(t)()
  417. pushDigest, err := setupImage()
  418. if err != nil {
  419. t.Fatalf("error setting up image: %v", err)
  420. }
  421. // pull from the registry using the <name>@<digest> reference
  422. imageReference := fmt.Sprintf("%s@%s", repoName, pushDigest)
  423. c := exec.Command(dockerBinary, "pull", imageReference)
  424. out, _, err := runCommandWithOutput(c)
  425. if err != nil {
  426. t.Fatalf("error pulling by digest: %s, %v", out, err)
  427. }
  428. // just in case...
  429. defer deleteImages(imageReference)
  430. imageID, err := inspectField(imageReference, ".Id")
  431. if err != nil {
  432. t.Fatalf("error inspecting image id: %v", err)
  433. }
  434. c = exec.Command(dockerBinary, "rmi", imageID)
  435. if _, err := runCommand(c); err != nil {
  436. t.Fatalf("error deleting image by id: %v", err)
  437. }
  438. logDone("by_digest - delete image by id only pulled by digest")
  439. }