github.com/AbhinandanKurakure/podman/v3@v3.4.10/test/e2e/load_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"path/filepath"
     7  
     8  	. "github.com/containers/podman/v3/test/utils"
     9  	. "github.com/onsi/ginkgo"
    10  	. "github.com/onsi/gomega"
    11  	. "github.com/onsi/gomega/gexec"
    12  )
    13  
    14  var _ = Describe("Podman load", func() {
    15  	var (
    16  		tempdir    string
    17  		err        error
    18  		podmanTest *PodmanTestIntegration
    19  	)
    20  
    21  	BeforeEach(func() {
    22  		tempdir, err = CreateTempDirInTempDir()
    23  		if err != nil {
    24  			os.Exit(1)
    25  		}
    26  		podmanTest = PodmanTestCreate(tempdir)
    27  		podmanTest.Setup()
    28  		podmanTest.AddImageToRWStore(ALPINE)
    29  	})
    30  
    31  	AfterEach(func() {
    32  		podmanTest.Cleanup()
    33  		f := CurrentGinkgoTestDescription()
    34  		processTestResult(f)
    35  
    36  	})
    37  
    38  	It("podman load input flag", func() {
    39  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
    40  
    41  		images := podmanTest.Podman([]string{"images"})
    42  		images.WaitWithDefaultTimeout()
    43  		fmt.Println(images.OutputToStringArray())
    44  
    45  		save := podmanTest.Podman([]string{"save", "-o", outfile, ALPINE})
    46  		save.WaitWithDefaultTimeout()
    47  		Expect(save).Should(Exit(0))
    48  
    49  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
    50  		rmi.WaitWithDefaultTimeout()
    51  		Expect(rmi).Should(Exit(0))
    52  
    53  		result := podmanTest.Podman([]string{"load", "-i", outfile})
    54  		result.WaitWithDefaultTimeout()
    55  		Expect(result).Should(Exit(0))
    56  	})
    57  
    58  	It("podman load compressed tar file", func() {
    59  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
    60  
    61  		save := podmanTest.Podman([]string{"save", "-o", outfile, ALPINE})
    62  		save.WaitWithDefaultTimeout()
    63  		Expect(save).Should(Exit(0))
    64  
    65  		compress := SystemExec("gzip", []string{outfile})
    66  		Expect(compress).Should(Exit(0))
    67  		outfile = outfile + ".gz"
    68  
    69  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
    70  		rmi.WaitWithDefaultTimeout()
    71  		Expect(rmi).Should(Exit(0))
    72  
    73  		result := podmanTest.Podman([]string{"load", "-i", outfile})
    74  		result.WaitWithDefaultTimeout()
    75  		Expect(result).Should(Exit(0))
    76  	})
    77  
    78  	It("podman load oci-archive image", func() {
    79  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
    80  
    81  		save := podmanTest.Podman([]string{"save", "-o", outfile, "--format", "oci-archive", ALPINE})
    82  		save.WaitWithDefaultTimeout()
    83  		Expect(save).Should(Exit(0))
    84  
    85  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
    86  		rmi.WaitWithDefaultTimeout()
    87  		Expect(rmi).Should(Exit(0))
    88  
    89  		result := podmanTest.Podman([]string{"load", "-i", outfile})
    90  		result.WaitWithDefaultTimeout()
    91  		Expect(result).Should(Exit(0))
    92  	})
    93  
    94  	It("podman load oci-archive with signature", func() {
    95  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
    96  
    97  		save := podmanTest.Podman([]string{"save", "-o", outfile, "--format", "oci-archive", ALPINE})
    98  		save.WaitWithDefaultTimeout()
    99  		Expect(save).Should(Exit(0))
   100  
   101  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
   102  		rmi.WaitWithDefaultTimeout()
   103  		Expect(rmi).Should(Exit(0))
   104  
   105  		result := podmanTest.Podman([]string{"load", "--signature-policy", "/etc/containers/policy.json", "-i", outfile})
   106  		result.WaitWithDefaultTimeout()
   107  		Expect(result).Should(Exit(0))
   108  	})
   109  
   110  	It("podman load with quiet flag", func() {
   111  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
   112  
   113  		save := podmanTest.Podman([]string{"save", "-o", outfile, ALPINE})
   114  		save.WaitWithDefaultTimeout()
   115  		Expect(save).Should(Exit(0))
   116  
   117  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
   118  		rmi.WaitWithDefaultTimeout()
   119  		Expect(rmi).Should(Exit(0))
   120  
   121  		result := podmanTest.Podman([]string{"load", "-q", "-i", outfile})
   122  		result.WaitWithDefaultTimeout()
   123  		Expect(result).Should(Exit(0))
   124  	})
   125  
   126  	It("podman load directory", func() {
   127  		SkipIfRemote("Remote does not support loading directories")
   128  		outdir := filepath.Join(podmanTest.TempDir, "alpine")
   129  
   130  		save := podmanTest.Podman([]string{"save", "--format", "oci-dir", "-o", outdir, ALPINE})
   131  		save.WaitWithDefaultTimeout()
   132  		Expect(save).Should(Exit(0))
   133  
   134  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
   135  		rmi.WaitWithDefaultTimeout()
   136  		Expect(rmi).Should(Exit(0))
   137  
   138  		result := podmanTest.Podman([]string{"load", "-i", outdir})
   139  		result.WaitWithDefaultTimeout()
   140  		Expect(result).Should(Exit(0))
   141  	})
   142  
   143  	It("podman-remote load directory", func() {
   144  		// Remote-only test looking for the specific remote error
   145  		// message when trying to load a directory.
   146  		if !IsRemote() {
   147  			Skip("Remote only test")
   148  		}
   149  
   150  		result := podmanTest.Podman([]string{"load", "-i", podmanTest.TempDir})
   151  		result.WaitWithDefaultTimeout()
   152  		Expect(result).Should(Exit(125))
   153  
   154  		errMsg := fmt.Sprintf("remote client supports archives only but %q is a directory", podmanTest.TempDir)
   155  		found, _ := result.ErrorGrepString(errMsg)
   156  		Expect(found).Should(BeTrue())
   157  	})
   158  
   159  	It("podman load bogus file", func() {
   160  		save := podmanTest.Podman([]string{"load", "-i", "foobar.tar"})
   161  		save.WaitWithDefaultTimeout()
   162  		Expect(save).To(ExitWithError())
   163  	})
   164  
   165  	It("podman load multiple tags", func() {
   166  		if podmanTest.Host.Arch == "ppc64le" {
   167  			Skip("skip on ppc64le")
   168  		}
   169  		outfile := filepath.Join(podmanTest.TempDir, "alpine.tar")
   170  		alpVersion := "quay.io/libpod/alpine:3.2"
   171  
   172  		pull := podmanTest.Podman([]string{"pull", alpVersion})
   173  		pull.WaitWithDefaultTimeout()
   174  		Expect(pull).Should(Exit(0))
   175  
   176  		save := podmanTest.Podman([]string{"save", "-o", outfile, ALPINE, alpVersion})
   177  		save.WaitWithDefaultTimeout()
   178  		Expect(save).Should(Exit(0))
   179  
   180  		rmi := podmanTest.Podman([]string{"rmi", ALPINE, alpVersion})
   181  		rmi.WaitWithDefaultTimeout()
   182  		Expect(rmi).Should(Exit(0))
   183  
   184  		result := podmanTest.Podman([]string{"load", "-i", outfile})
   185  		result.WaitWithDefaultTimeout()
   186  		Expect(result).Should(Exit(0))
   187  
   188  		inspect := podmanTest.Podman([]string{"inspect", ALPINE})
   189  		inspect.WaitWithDefaultTimeout()
   190  		Expect(result).Should(Exit(0))
   191  		inspect = podmanTest.Podman([]string{"inspect", alpVersion})
   192  		inspect.WaitWithDefaultTimeout()
   193  		Expect(result).Should(Exit(0))
   194  	})
   195  
   196  	It("podman load localhost registry from scratch", func() {
   197  		outfile := filepath.Join(podmanTest.TempDir, "load_test.tar.gz")
   198  		setup := podmanTest.Podman([]string{"tag", ALPINE, "hello:world"})
   199  		setup.WaitWithDefaultTimeout()
   200  		Expect(setup).Should(Exit(0))
   201  
   202  		setup = podmanTest.Podman([]string{"save", "-o", outfile, "--format", "oci-archive", "hello:world"})
   203  		setup.WaitWithDefaultTimeout()
   204  		Expect(setup).Should(Exit(0))
   205  
   206  		setup = podmanTest.Podman([]string{"rmi", "hello:world"})
   207  		setup.WaitWithDefaultTimeout()
   208  		Expect(setup).Should(Exit(0))
   209  
   210  		load := podmanTest.Podman([]string{"load", "-i", outfile})
   211  		load.WaitWithDefaultTimeout()
   212  		Expect(load).Should(Exit(0))
   213  
   214  		result := podmanTest.Podman([]string{"images", "hello:world"})
   215  		result.WaitWithDefaultTimeout()
   216  		Expect(result.LineInOutputContains("docker")).To(Not(BeTrue()))
   217  		Expect(result.LineInOutputContains("localhost")).To(BeTrue())
   218  	})
   219  
   220  	It("podman load localhost registry from scratch and :latest", func() {
   221  		outfile := filepath.Join(podmanTest.TempDir, "load_test.tar.gz")
   222  
   223  		setup := podmanTest.Podman([]string{"tag", ALPINE, "hello"})
   224  		setup.WaitWithDefaultTimeout()
   225  		Expect(setup).Should(Exit(0))
   226  
   227  		setup = podmanTest.Podman([]string{"save", "-o", outfile, "--format", "oci-archive", "hello"})
   228  		setup.WaitWithDefaultTimeout()
   229  		Expect(setup).Should(Exit(0))
   230  
   231  		setup = podmanTest.Podman([]string{"rmi", "hello"})
   232  		setup.WaitWithDefaultTimeout()
   233  		Expect(setup).Should(Exit(0))
   234  
   235  		load := podmanTest.Podman([]string{"load", "-i", outfile})
   236  		load.WaitWithDefaultTimeout()
   237  		Expect(load).Should(Exit(0))
   238  
   239  		result := podmanTest.Podman([]string{"images", "hello:latest"})
   240  		result.WaitWithDefaultTimeout()
   241  		Expect(result.LineInOutputContains("docker")).To(Not(BeTrue()))
   242  		Expect(result.LineInOutputContains("localhost")).To(BeTrue())
   243  	})
   244  
   245  	It("podman load localhost registry from dir", func() {
   246  		SkipIfRemote("podman-remote does not support loading directories")
   247  		outfile := filepath.Join(podmanTest.TempDir, "load")
   248  
   249  		setup := podmanTest.Podman([]string{"tag", ALPINE, "hello:world"})
   250  		setup.WaitWithDefaultTimeout()
   251  		Expect(setup).Should(Exit(0))
   252  
   253  		setup = podmanTest.Podman([]string{"save", "-o", outfile, "--format", "oci-dir", "hello:world"})
   254  		setup.WaitWithDefaultTimeout()
   255  		Expect(setup).Should(Exit(0))
   256  
   257  		setup = podmanTest.Podman([]string{"rmi", "hello:world"})
   258  		setup.WaitWithDefaultTimeout()
   259  		Expect(setup).Should(Exit(0))
   260  
   261  		load := podmanTest.Podman([]string{"load", "-i", outfile})
   262  		load.WaitWithDefaultTimeout()
   263  		Expect(load).Should(Exit(0))
   264  
   265  		result := podmanTest.Podman([]string{"images", "load:latest"})
   266  		result.WaitWithDefaultTimeout()
   267  		Expect(result.LineInOutputContains("docker")).To(Not(BeTrue()))
   268  		Expect(result.LineInOutputContains("localhost")).To(BeTrue())
   269  	})
   270  
   271  	It("podman load xz compressed image", func() {
   272  		outfile := filepath.Join(podmanTest.TempDir, "alp.tar")
   273  
   274  		save := podmanTest.Podman([]string{"save", "-o", outfile, ALPINE})
   275  		save.WaitWithDefaultTimeout()
   276  		Expect(save).Should(Exit(0))
   277  		session := SystemExec("xz", []string{outfile})
   278  		Expect(session).Should(Exit(0))
   279  
   280  		rmi := podmanTest.Podman([]string{"rmi", ALPINE})
   281  		rmi.WaitWithDefaultTimeout()
   282  		Expect(rmi).Should(Exit(0))
   283  
   284  		result := podmanTest.Podman([]string{"load", "-i", outfile + ".xz"})
   285  		result.WaitWithDefaultTimeout()
   286  		Expect(result).Should(Exit(0))
   287  	})
   288  
   289  	It("podman load multi-image archive", func() {
   290  		result := podmanTest.Podman([]string{"load", "-i", "./testdata/docker-two-images.tar.xz"})
   291  		result.WaitWithDefaultTimeout()
   292  		Expect(result).Should(Exit(0))
   293  		Expect(result.LineInOutputContains("example.com/empty:latest")).To(BeTrue())
   294  		Expect(result.LineInOutputContains("example.com/empty/but:different")).To(BeTrue())
   295  	})
   296  })