github.com/hanks177/podman/v4@v4.1.3-0.20220613032544-16d90015bc83/test/e2e/import_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"os"
     5  	"path/filepath"
     6  
     7  	. "github.com/hanks177/podman/v4/test/utils"
     8  	. "github.com/onsi/ginkgo"
     9  	. "github.com/onsi/gomega"
    10  	. "github.com/onsi/gomega/gexec"
    11  )
    12  
    13  var _ = Describe("Podman import", func() {
    14  	var (
    15  		tempdir    string
    16  		err        error
    17  		podmanTest *PodmanTestIntegration
    18  	)
    19  
    20  	BeforeEach(func() {
    21  		tempdir, err = CreateTempDirInTempDir()
    22  		if err != nil {
    23  			os.Exit(1)
    24  		}
    25  		podmanTest = PodmanTestCreate(tempdir)
    26  		podmanTest.Setup()
    27  	})
    28  
    29  	AfterEach(func() {
    30  		podmanTest.Cleanup()
    31  		f := CurrentGinkgoTestDescription()
    32  		processTestResult(f)
    33  
    34  	})
    35  
    36  	It("podman import with source and reference", func() {
    37  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
    38  		_, ec, cid := podmanTest.RunLsContainer("")
    39  		Expect(ec).To(Equal(0))
    40  
    41  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
    42  		export.WaitWithDefaultTimeout()
    43  		Expect(export).Should(Exit(0))
    44  
    45  		importImage := podmanTest.Podman([]string{"import", outfile, "foobar.com/imported-image:latest"})
    46  		importImage.WaitWithDefaultTimeout()
    47  		Expect(importImage).Should(Exit(0))
    48  
    49  		results := podmanTest.Podman([]string{"inspect", "--type", "image", "foobar.com/imported-image:latest"})
    50  		results.WaitWithDefaultTimeout()
    51  		Expect(results).Should(Exit(0))
    52  	})
    53  
    54  	It("podman import with custom os, arch and variant", func() {
    55  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
    56  		_, ec, cid := podmanTest.RunLsContainer("")
    57  		Expect(ec).To(Equal(0))
    58  
    59  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
    60  		export.WaitWithDefaultTimeout()
    61  		Expect(export).Should(Exit(0))
    62  
    63  		importImage := podmanTest.Podman([]string{"import", "--os", "testos", "--arch", "testarch", outfile, "foobar.com/imported-image:latest"})
    64  		importImage.WaitWithDefaultTimeout()
    65  		Expect(importImage).Should(Exit(0))
    66  
    67  		results := podmanTest.Podman([]string{"inspect", "--type", "image", "foobar.com/imported-image:latest"})
    68  		results.WaitWithDefaultTimeout()
    69  		Expect(results).Should(Exit(0))
    70  		Expect(results.OutputToString()).To(ContainSubstring("testos"))
    71  		Expect(results.OutputToString()).To(ContainSubstring("testarch"))
    72  	})
    73  
    74  	It("podman import without reference", func() {
    75  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
    76  		_, ec, cid := podmanTest.RunLsContainer("")
    77  		Expect(ec).To(Equal(0))
    78  
    79  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
    80  		export.WaitWithDefaultTimeout()
    81  		Expect(export).Should(Exit(0))
    82  
    83  		importImage := podmanTest.Podman([]string{"import", outfile})
    84  		importImage.WaitWithDefaultTimeout()
    85  		Expect(importImage).Should(Exit(0))
    86  
    87  		// tag the image which proves it is in R/W storage
    88  		tag := podmanTest.Podman([]string{"tag", importImage.OutputToString(), "foo"})
    89  		tag.WaitWithDefaultTimeout()
    90  		Expect(tag).Should(Exit(0))
    91  	})
    92  
    93  	It("podman import with message flag", func() {
    94  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
    95  		_, ec, cid := podmanTest.RunLsContainer("")
    96  		Expect(ec).To(Equal(0))
    97  
    98  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
    99  		export.WaitWithDefaultTimeout()
   100  		Expect(export).Should(Exit(0))
   101  
   102  		importImage := podmanTest.Podman([]string{"import", "--message", "importing container test message", outfile, "imported-image"})
   103  		importImage.WaitWithDefaultTimeout()
   104  		Expect(importImage).Should(Exit(0))
   105  
   106  		results := podmanTest.Podman([]string{"history", "imported-image", "--format", "{{.Comment}}"})
   107  		results.WaitWithDefaultTimeout()
   108  		Expect(results).Should(Exit(0))
   109  		Expect(results.OutputToStringArray()).To(ContainElement(HavePrefix("importing container test message")))
   110  	})
   111  
   112  	It("podman import with change flag CMD=<path>", func() {
   113  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
   114  		_, ec, cid := podmanTest.RunLsContainer("")
   115  		Expect(ec).To(Equal(0))
   116  
   117  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
   118  		export.WaitWithDefaultTimeout()
   119  		Expect(export).Should(Exit(0))
   120  
   121  		importImage := podmanTest.Podman([]string{"import", "--change", "CMD=/bin/bash", outfile, "imported-image"})
   122  		importImage.WaitWithDefaultTimeout()
   123  		Expect(importImage).Should(Exit(0))
   124  
   125  		results := podmanTest.Podman([]string{"inspect", "imported-image"})
   126  		results.WaitWithDefaultTimeout()
   127  		Expect(results).Should(Exit(0))
   128  		imageData := results.InspectImageJSON()
   129  		Expect(imageData[0].Config.Cmd[0]).To(Equal("/bin/sh"))
   130  		Expect(imageData[0].Config.Cmd[1]).To(Equal("-c"))
   131  		Expect(imageData[0].Config.Cmd[2]).To(Equal("/bin/bash"))
   132  	})
   133  
   134  	It("podman import with change flag CMD <path>", func() {
   135  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
   136  		_, ec, cid := podmanTest.RunLsContainer("")
   137  		Expect(ec).To(Equal(0))
   138  
   139  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
   140  		export.WaitWithDefaultTimeout()
   141  		Expect(export).Should(Exit(0))
   142  
   143  		importImage := podmanTest.Podman([]string{"import", "--change", "CMD /bin/sh", outfile, "imported-image"})
   144  		importImage.WaitWithDefaultTimeout()
   145  		Expect(importImage).Should(Exit(0))
   146  
   147  		results := podmanTest.Podman([]string{"inspect", "imported-image"})
   148  		results.WaitWithDefaultTimeout()
   149  		Expect(results).Should(Exit(0))
   150  		imageData := results.InspectImageJSON()
   151  		Expect(imageData[0].Config.Cmd[0]).To(Equal("/bin/sh"))
   152  		Expect(imageData[0].Config.Cmd[1]).To(Equal("-c"))
   153  		Expect(imageData[0].Config.Cmd[2]).To(Equal("/bin/sh"))
   154  	})
   155  
   156  	It("podman import with change flag CMD [\"path\",\"path'\"", func() {
   157  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
   158  		_, ec, cid := podmanTest.RunLsContainer("")
   159  		Expect(ec).To(Equal(0))
   160  
   161  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
   162  		export.WaitWithDefaultTimeout()
   163  		Expect(export).Should(Exit(0))
   164  
   165  		importImage := podmanTest.Podman([]string{"import", "--change", "CMD [\"/bin/bash\"]", outfile, "imported-image"})
   166  		importImage.WaitWithDefaultTimeout()
   167  		Expect(importImage).Should(Exit(0))
   168  
   169  		results := podmanTest.Podman([]string{"inspect", "imported-image"})
   170  		results.WaitWithDefaultTimeout()
   171  		Expect(results).Should(Exit(0))
   172  		imageData := results.InspectImageJSON()
   173  		Expect(imageData[0].Config.Cmd[0]).To(Equal("/bin/bash"))
   174  	})
   175  
   176  	It("podman import with signature", func() {
   177  		SkipIfRemote("--signature-policy N/A for remote")
   178  
   179  		outfile := filepath.Join(podmanTest.TempDir, "container.tar")
   180  		_, ec, cid := podmanTest.RunLsContainer("")
   181  		Expect(ec).To(Equal(0))
   182  
   183  		export := podmanTest.Podman([]string{"export", "-o", outfile, cid})
   184  		export.WaitWithDefaultTimeout()
   185  		Expect(export).Should(Exit(0))
   186  
   187  		importImage := podmanTest.Podman([]string{"import", "--signature-policy", "/no/such/file", outfile})
   188  		importImage.WaitWithDefaultTimeout()
   189  		Expect(importImage).To(ExitWithError())
   190  
   191  		result := podmanTest.Podman([]string{"import", "--signature-policy", "/etc/containers/policy.json", outfile})
   192  		result.WaitWithDefaultTimeout()
   193  		if IsRemote() {
   194  			Expect(result).To(ExitWithError())
   195  			Expect(result.ErrorToString()).To(ContainSubstring("unknown flag"))
   196  			result := podmanTest.Podman([]string{"import", outfile})
   197  			result.WaitWithDefaultTimeout()
   198  		}
   199  		Expect(result).Should(Exit(0))
   200  	})
   201  })