github.com/containers/podman/v5@v5.1.0-rc1/test/e2e/mount_test.go (about)

     1  package integration
     2  
     3  import (
     4  	. "github.com/containers/podman/v5/test/utils"
     5  	. "github.com/onsi/ginkgo/v2"
     6  	. "github.com/onsi/gomega"
     7  )
     8  
     9  var _ = Describe("Podman mount", func() {
    10  
    11  	BeforeEach(func() {
    12  		SkipIfRemote("Podman mount not supported for remote connections")
    13  		SkipIfRootless("Podman mount requires podman unshare first to work")
    14  		podmanTest.AddImageToRWStore(ALPINE)
    15  	})
    16  
    17  	It("podman mount", func() {
    18  		setup := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    19  		setup.WaitWithDefaultTimeout()
    20  		Expect(setup).Should(ExitCleanly())
    21  		cid := setup.OutputToString()
    22  
    23  		mount := podmanTest.Podman([]string{"mount", cid})
    24  		mount.WaitWithDefaultTimeout()
    25  		Expect(mount).Should(ExitCleanly())
    26  
    27  		umount := podmanTest.Podman([]string{"umount", cid})
    28  		umount.WaitWithDefaultTimeout()
    29  		Expect(umount).Should(ExitCleanly())
    30  	})
    31  
    32  	It("podman container mount", func() {
    33  		setup := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
    34  		setup.WaitWithDefaultTimeout()
    35  		Expect(setup).Should(ExitCleanly())
    36  		cid := setup.OutputToString()
    37  
    38  		mount := podmanTest.Podman([]string{"container", "mount", cid})
    39  		mount.WaitWithDefaultTimeout()
    40  		Expect(mount).Should(ExitCleanly())
    41  
    42  		umount := podmanTest.Podman([]string{"container", "umount", cid})
    43  		umount.WaitWithDefaultTimeout()
    44  		Expect(umount).Should(ExitCleanly())
    45  	})
    46  
    47  	It("podman mount with json format", func() {
    48  		setup := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    49  		setup.WaitWithDefaultTimeout()
    50  		Expect(setup).Should(ExitCleanly())
    51  		cid := setup.OutputToString()
    52  
    53  		mount := podmanTest.Podman([]string{"mount", cid})
    54  		mount.WaitWithDefaultTimeout()
    55  		Expect(mount).Should(ExitCleanly())
    56  
    57  		j := podmanTest.Podman([]string{"mount", "--format=json"})
    58  		j.WaitWithDefaultTimeout()
    59  		Expect(j).Should(ExitCleanly())
    60  		Expect(j.OutputToString()).To(BeValidJSON())
    61  
    62  		j = podmanTest.Podman([]string{"mount", "--format={{.foobar}}"})
    63  		j.WaitWithDefaultTimeout()
    64  		Expect(j).To(ExitWithError(125, `unknown --format argument: "{{.foobar}}"`))
    65  
    66  		umount := podmanTest.Podman([]string{"umount", cid})
    67  		umount.WaitWithDefaultTimeout()
    68  		Expect(umount).Should(ExitCleanly())
    69  	})
    70  
    71  	It("podman mount many", func() {
    72  		setup1 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    73  		setup1.WaitWithDefaultTimeout()
    74  		Expect(setup1).Should(ExitCleanly())
    75  		cid1 := setup1.OutputToString()
    76  
    77  		setup2 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    78  		setup2.WaitWithDefaultTimeout()
    79  		Expect(setup2).Should(ExitCleanly())
    80  		cid2 := setup2.OutputToString()
    81  
    82  		setup3 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    83  		setup3.WaitWithDefaultTimeout()
    84  		Expect(setup3).Should(ExitCleanly())
    85  		cid3 := setup3.OutputToString()
    86  
    87  		mount1 := podmanTest.Podman([]string{"mount", cid1, cid2, cid3})
    88  		mount1.WaitWithDefaultTimeout()
    89  		Expect(mount1).Should(ExitCleanly())
    90  
    91  		umount := podmanTest.Podman([]string{"umount", cid1, cid2, cid3})
    92  		umount.WaitWithDefaultTimeout()
    93  		Expect(umount).Should(ExitCleanly())
    94  	})
    95  
    96  	It("podman umount many", func() {
    97  		setup1 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    98  		setup1.WaitWithDefaultTimeout()
    99  		Expect(setup1).Should(ExitCleanly())
   100  		cid1 := setup1.OutputToString()
   101  
   102  		setup2 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   103  		setup2.WaitWithDefaultTimeout()
   104  		Expect(setup2).Should(ExitCleanly())
   105  		cid2 := setup2.OutputToString()
   106  
   107  		mount1 := podmanTest.Podman([]string{"mount", cid1})
   108  		mount1.WaitWithDefaultTimeout()
   109  		Expect(mount1).Should(ExitCleanly())
   110  
   111  		mount2 := podmanTest.Podman([]string{"mount", cid2})
   112  		mount2.WaitWithDefaultTimeout()
   113  		Expect(mount2).Should(ExitCleanly())
   114  
   115  		umount := podmanTest.Podman([]string{"umount", cid1, cid2})
   116  		umount.WaitWithDefaultTimeout()
   117  		Expect(umount).Should(ExitCleanly())
   118  	})
   119  
   120  	It("podman umount all", func() {
   121  		setup1 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   122  		setup1.WaitWithDefaultTimeout()
   123  		Expect(setup1).Should(ExitCleanly())
   124  		cid1 := setup1.OutputToString()
   125  
   126  		setup2 := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   127  		setup2.WaitWithDefaultTimeout()
   128  		Expect(setup2).Should(ExitCleanly())
   129  		cid2 := setup2.OutputToString()
   130  
   131  		mount1 := podmanTest.Podman([]string{"mount", cid1})
   132  		mount1.WaitWithDefaultTimeout()
   133  		Expect(mount1).Should(ExitCleanly())
   134  
   135  		mount2 := podmanTest.Podman([]string{"mount", cid2})
   136  		mount2.WaitWithDefaultTimeout()
   137  		Expect(mount2).Should(ExitCleanly())
   138  
   139  		umount := podmanTest.Podman([]string{"umount", "--all"})
   140  		umount.WaitWithDefaultTimeout()
   141  		Expect(umount).Should(ExitCleanly())
   142  	})
   143  
   144  	It("podman list mounted container", func() {
   145  		setup := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   146  		setup.WaitWithDefaultTimeout()
   147  		Expect(setup).Should(ExitCleanly())
   148  		cid := setup.OutputToString()
   149  
   150  		lmount := podmanTest.Podman([]string{"mount", "--no-trunc"})
   151  		lmount.WaitWithDefaultTimeout()
   152  		Expect(lmount).Should(ExitCleanly())
   153  		Expect(lmount.OutputToString()).To(Equal(""))
   154  
   155  		mount := podmanTest.Podman([]string{"mount", cid})
   156  		mount.WaitWithDefaultTimeout()
   157  		Expect(mount).Should(ExitCleanly())
   158  
   159  		lmount = podmanTest.Podman([]string{"mount", "--no-trunc"})
   160  		lmount.WaitWithDefaultTimeout()
   161  		Expect(lmount).Should(ExitCleanly())
   162  		Expect(lmount.OutputToString()).To(ContainSubstring(cid))
   163  
   164  		umount := podmanTest.Podman([]string{"umount", cid})
   165  		umount.WaitWithDefaultTimeout()
   166  		Expect(umount).Should(ExitCleanly())
   167  	})
   168  
   169  	It("podman list running container", func() {
   170  
   171  		setup := podmanTest.Podman([]string{"run", "-dt", ALPINE, "top"})
   172  		setup.WaitWithDefaultTimeout()
   173  		Expect(setup).Should(ExitCleanly())
   174  		cid := setup.OutputToString()
   175  
   176  		lmount := podmanTest.Podman([]string{"mount", "--no-trunc"})
   177  		lmount.WaitWithDefaultTimeout()
   178  		Expect(lmount).Should(ExitCleanly())
   179  		Expect(lmount.OutputToString()).To(ContainSubstring(cid))
   180  
   181  		podmanTest.StopContainer(cid)
   182  
   183  		lmount = podmanTest.Podman([]string{"mount", "--no-trunc"})
   184  		lmount.WaitWithDefaultTimeout()
   185  		Expect(lmount).Should(ExitCleanly())
   186  		Expect(lmount.OutputToString()).To(Equal(""))
   187  	})
   188  
   189  	It("podman list multiple mounted containers", func() {
   190  
   191  		setup := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   192  		setup.WaitWithDefaultTimeout()
   193  		Expect(setup).Should(ExitCleanly())
   194  		cid1 := setup.OutputToString()
   195  
   196  		setup = podmanTest.Podman([]string{"create", ALPINE, "ls"})
   197  		setup.WaitWithDefaultTimeout()
   198  		Expect(setup).Should(ExitCleanly())
   199  		cid2 := setup.OutputToString()
   200  
   201  		setup = podmanTest.Podman([]string{"create", ALPINE, "ls"})
   202  		setup.WaitWithDefaultTimeout()
   203  		Expect(setup).Should(ExitCleanly())
   204  		cid3 := setup.OutputToString()
   205  
   206  		lmount := podmanTest.Podman([]string{"mount", "--no-trunc"})
   207  		lmount.WaitWithDefaultTimeout()
   208  		Expect(lmount).Should(ExitCleanly())
   209  		Expect(lmount.OutputToString()).To(Equal(""))
   210  
   211  		mount := podmanTest.Podman([]string{"mount", cid1, cid3})
   212  		mount.WaitWithDefaultTimeout()
   213  		Expect(mount).Should(ExitCleanly())
   214  
   215  		lmount = podmanTest.Podman([]string{"mount", "--no-trunc"})
   216  		lmount.WaitWithDefaultTimeout()
   217  		Expect(lmount).Should(ExitCleanly())
   218  		Expect(lmount.OutputToString()).To(ContainSubstring(cid1))
   219  		Expect(lmount.OutputToString()).ToNot(ContainSubstring(cid2))
   220  		Expect(lmount.OutputToString()).To(ContainSubstring(cid3))
   221  
   222  		umount := podmanTest.Podman([]string{"umount", cid1, cid3})
   223  		umount.WaitWithDefaultTimeout()
   224  		Expect(umount).Should(ExitCleanly())
   225  
   226  		lmount = podmanTest.Podman([]string{"mount", "--no-trunc"})
   227  		lmount.WaitWithDefaultTimeout()
   228  		Expect(lmount).Should(ExitCleanly())
   229  		Expect(lmount.OutputToString()).To(Equal(""))
   230  
   231  	})
   232  
   233  	It("podman list mounted container", func() {
   234  
   235  		setup := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   236  		setup.WaitWithDefaultTimeout()
   237  		Expect(setup).Should(ExitCleanly())
   238  		cid := setup.OutputToString()
   239  
   240  		lmount := podmanTest.Podman([]string{"mount", "--no-trunc"})
   241  		lmount.WaitWithDefaultTimeout()
   242  		Expect(lmount).Should(ExitCleanly())
   243  		Expect(lmount.OutputToString()).To(Equal(""))
   244  
   245  		mount := podmanTest.Podman([]string{"mount", cid})
   246  		mount.WaitWithDefaultTimeout()
   247  		Expect(mount).Should(ExitCleanly())
   248  
   249  		// test --notruncate alias
   250  		lmount = podmanTest.Podman([]string{"mount", "--notruncate"})
   251  		lmount.WaitWithDefaultTimeout()
   252  		Expect(lmount).Should(ExitCleanly())
   253  		Expect(lmount.OutputToString()).To(ContainSubstring(cid))
   254  
   255  		umount := podmanTest.Podman([]string{"umount", cid})
   256  		umount.WaitWithDefaultTimeout()
   257  		Expect(umount).Should(ExitCleanly())
   258  	})
   259  
   260  	It("podman image mount", func() {
   261  		images := podmanTest.Podman([]string{"images"})
   262  		images.WaitWithDefaultTimeout()
   263  		Expect(images).Should(ExitCleanly())
   264  
   265  		mount := podmanTest.Podman([]string{"image", "mount", ALPINE})
   266  		mount.WaitWithDefaultTimeout()
   267  		Expect(mount).Should(ExitCleanly())
   268  
   269  		umount := podmanTest.Podman([]string{"image", "umount", ALPINE})
   270  		umount.WaitWithDefaultTimeout()
   271  		Expect(umount).Should(ExitCleanly())
   272  
   273  		mount = podmanTest.Podman([]string{"image", "mount"})
   274  		mount.WaitWithDefaultTimeout()
   275  		Expect(mount).Should(ExitCleanly())
   276  		Expect(mount.OutputToString()).To(Equal(""))
   277  
   278  		// Mount multiple times
   279  		mount = podmanTest.Podman([]string{"image", "mount", ALPINE})
   280  		mount.WaitWithDefaultTimeout()
   281  		Expect(mount).Should(ExitCleanly())
   282  
   283  		mount = podmanTest.Podman([]string{"image", "mount", ALPINE})
   284  		mount.WaitWithDefaultTimeout()
   285  		Expect(mount).Should(ExitCleanly())
   286  
   287  		// Unmount once
   288  		mount = podmanTest.Podman([]string{"image", "mount", ALPINE})
   289  		mount.WaitWithDefaultTimeout()
   290  		Expect(mount).Should(ExitCleanly())
   291  
   292  		mount = podmanTest.Podman([]string{"image", "mount"})
   293  		mount.WaitWithDefaultTimeout()
   294  		Expect(mount).Should(ExitCleanly())
   295  		Expect(mount.OutputToString()).To(ContainSubstring(ALPINE))
   296  
   297  		mount = podmanTest.Podman([]string{"image", "umount", "--all"})
   298  		mount.WaitWithDefaultTimeout()
   299  		Expect(mount).Should(ExitCleanly())
   300  	})
   301  
   302  	It("podman mount with json format", func() {
   303  		podmanTest.AddImageToRWStore(fedoraMinimal)
   304  		mount := podmanTest.Podman([]string{"image", "mount", fedoraMinimal})
   305  		mount.WaitWithDefaultTimeout()
   306  		Expect(mount).Should(ExitCleanly())
   307  
   308  		j := podmanTest.Podman([]string{"image", "mount", "--format=json"})
   309  		j.WaitWithDefaultTimeout()
   310  		Expect(j).Should(ExitCleanly())
   311  		Expect(j.OutputToString()).To(BeValidJSON())
   312  
   313  		umount := podmanTest.Podman([]string{"image", "umount", fedoraMinimal})
   314  		umount.WaitWithDefaultTimeout()
   315  		Expect(umount).Should(ExitCleanly())
   316  	})
   317  
   318  	It("podman umount --all", func() {
   319  		podmanTest.AddImageToRWStore(fedoraMinimal)
   320  		mount := podmanTest.Podman([]string{"image", "mount", fedoraMinimal})
   321  		mount.WaitWithDefaultTimeout()
   322  		Expect(mount).Should(ExitCleanly())
   323  
   324  		umount := podmanTest.Podman([]string{"image", "umount", "--all"})
   325  		umount.WaitWithDefaultTimeout()
   326  		Expect(umount).Should(ExitCleanly())
   327  		Expect(umount.OutputToStringArray()).To(HaveLen(1))
   328  	})
   329  
   330  	It("podman mount many", func() {
   331  		Skip("Issue where using short name when we have a lookaside store")
   332  		podmanTest.AddImageToRWStore(fedoraMinimal)
   333  		podmanTest.AddImageToRWStore(BB)
   334  
   335  		mount1 := podmanTest.Podman([]string{"image", "mount", fedoraMinimal, ALPINE, "busybox"})
   336  		mount1.WaitWithDefaultTimeout()
   337  		Expect(mount1).Should(ExitCleanly())
   338  
   339  		umount := podmanTest.Podman([]string{"image", "umount", fedoraMinimal, ALPINE})
   340  		umount.WaitWithDefaultTimeout()
   341  		Expect(umount).Should(ExitCleanly())
   342  
   343  		mount := podmanTest.Podman([]string{"image", "mount"})
   344  		mount.WaitWithDefaultTimeout()
   345  		Expect(mount).Should(ExitCleanly())
   346  		Expect(mount.OutputToString()).To(ContainSubstring("busybox"))
   347  
   348  		mount1 = podmanTest.Podman([]string{"image", "unmount", "busybox"})
   349  		mount1.WaitWithDefaultTimeout()
   350  		Expect(mount1).Should(ExitCleanly())
   351  
   352  		mount = podmanTest.Podman([]string{"image", "mount"})
   353  		mount.WaitWithDefaultTimeout()
   354  		Expect(mount).Should(ExitCleanly())
   355  		Expect(mount.OutputToString()).To(Equal(""))
   356  
   357  		mount1 = podmanTest.Podman([]string{"image", "mount", fedoraMinimal, ALPINE, "busybox"})
   358  		mount1.WaitWithDefaultTimeout()
   359  		Expect(mount1).Should(ExitCleanly())
   360  
   361  		mount = podmanTest.Podman([]string{"image", "mount"})
   362  		mount.WaitWithDefaultTimeout()
   363  		Expect(mount).Should(ExitCleanly())
   364  		Expect(mount.OutputToString()).To(ContainSubstring(fedoraMinimal))
   365  		Expect(mount.OutputToString()).To(ContainSubstring(ALPINE))
   366  
   367  		umount = podmanTest.Podman([]string{"image", "umount", "--all"})
   368  		umount.WaitWithDefaultTimeout()
   369  		Expect(umount).Should(ExitCleanly())
   370  
   371  		mount = podmanTest.Podman([]string{"image", "mount"})
   372  		mount.WaitWithDefaultTimeout()
   373  		Expect(mount).Should(ExitCleanly())
   374  		Expect(mount.OutputToString()).To(Equal(""))
   375  
   376  		umount = podmanTest.Podman([]string{"image", "umount", fedoraMinimal, ALPINE})
   377  		umount.WaitWithDefaultTimeout()
   378  		Expect(umount).Should(ExitCleanly())
   379  
   380  		mount1 = podmanTest.Podman([]string{"image", "mount", "--all"})
   381  		mount1.WaitWithDefaultTimeout()
   382  		Expect(mount1).Should(ExitCleanly())
   383  
   384  		mount = podmanTest.Podman([]string{"image", "mount"})
   385  		mount.WaitWithDefaultTimeout()
   386  		Expect(mount).Should(ExitCleanly())
   387  		Expect(mount.OutputToString()).To(ContainSubstring(fedoraMinimal))
   388  		Expect(mount.OutputToString()).To(ContainSubstring(ALPINE))
   389  
   390  		umount = podmanTest.Podman([]string{"image", "umount", "--all"})
   391  		umount.WaitWithDefaultTimeout()
   392  		Expect(umount).Should(ExitCleanly())
   393  
   394  		mount = podmanTest.Podman([]string{"image", "mount"})
   395  		mount.WaitWithDefaultTimeout()
   396  		Expect(mount).Should(ExitCleanly())
   397  		Expect(mount.OutputToString()).To(Equal(""))
   398  	})
   399  })