github.com/containers/podman/v4@v4.9.4/test/e2e/rm_test.go (about)

     1  package integration
     2  
     3  import (
     4  	"fmt"
     5  
     6  	. "github.com/containers/podman/v4/test/utils"
     7  	. "github.com/onsi/ginkgo/v2"
     8  	. "github.com/onsi/gomega"
     9  	. "github.com/onsi/gomega/gexec"
    10  )
    11  
    12  var _ = Describe("Podman rm", func() {
    13  
    14  	It("podman rm stopped container", func() {
    15  		_, ec, cid := podmanTest.RunLsContainer("")
    16  		Expect(ec).To(Equal(0))
    17  
    18  		result := podmanTest.Podman([]string{"rm", cid})
    19  		result.WaitWithDefaultTimeout()
    20  		Expect(result).Should(ExitCleanly())
    21  	})
    22  
    23  	It("podman rm refuse to remove a running container", func() {
    24  		session := podmanTest.RunTopContainer("")
    25  		session.WaitWithDefaultTimeout()
    26  		Expect(session).Should(ExitCleanly())
    27  		cid := session.OutputToString()
    28  
    29  		result := podmanTest.Podman([]string{"rm", cid})
    30  		result.WaitWithDefaultTimeout()
    31  		Expect(result).Should(Exit(2))
    32  		Expect(result.ErrorToString()).To(ContainSubstring("containers cannot be removed without force"))
    33  	})
    34  
    35  	It("podman rm created container", func() {
    36  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    37  		session.WaitWithDefaultTimeout()
    38  		Expect(session).Should(ExitCleanly())
    39  		cid := session.OutputToString()
    40  
    41  		result := podmanTest.Podman([]string{"rm", cid})
    42  		result.WaitWithDefaultTimeout()
    43  		Expect(result).Should(ExitCleanly())
    44  	})
    45  
    46  	It("podman container rm created container", func() {
    47  		session := podmanTest.Podman([]string{"container", "create", ALPINE, "ls"})
    48  		session.WaitWithDefaultTimeout()
    49  		Expect(session).Should(ExitCleanly())
    50  		cid := session.OutputToString()
    51  
    52  		result := podmanTest.Podman([]string{"container", "rm", cid})
    53  		result.WaitWithDefaultTimeout()
    54  		Expect(result).Should(ExitCleanly())
    55  	})
    56  
    57  	It("podman rm running container with -f", func() {
    58  		session := podmanTest.RunTopContainer("")
    59  		session.WaitWithDefaultTimeout()
    60  		Expect(session).Should(ExitCleanly())
    61  		cid := session.OutputToString()
    62  
    63  		result := podmanTest.Podman([]string{"rm", "-t", "0", "-f", cid})
    64  		result.WaitWithDefaultTimeout()
    65  		Expect(result).Should(ExitCleanly())
    66  	})
    67  
    68  	It("podman rm all containers", func() {
    69  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    70  		session.WaitWithDefaultTimeout()
    71  		Expect(session).Should(ExitCleanly())
    72  
    73  		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
    74  		session.WaitWithDefaultTimeout()
    75  		Expect(session).Should(ExitCleanly())
    76  
    77  		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
    78  		session.WaitWithDefaultTimeout()
    79  		Expect(session).Should(ExitCleanly())
    80  
    81  		result := podmanTest.Podman([]string{"rm", "-a"})
    82  		result.WaitWithDefaultTimeout()
    83  		Expect(result).Should(ExitCleanly())
    84  	})
    85  
    86  	It("podman rm all containers with one running and short options", func() {
    87  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
    88  		session.WaitWithDefaultTimeout()
    89  		Expect(session).Should(ExitCleanly())
    90  
    91  		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
    92  		session.WaitWithDefaultTimeout()
    93  		Expect(session).Should(ExitCleanly())
    94  
    95  		session = podmanTest.RunTopContainer("")
    96  		session.WaitWithDefaultTimeout()
    97  		Expect(session).Should(ExitCleanly())
    98  
    99  		result := podmanTest.Podman([]string{"rm", "-af"})
   100  		result.WaitWithDefaultTimeout()
   101  		Expect(result).Should(ExitCleanly())
   102  	})
   103  
   104  	It("podman rm the latest container", func() {
   105  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   106  		session.WaitWithDefaultTimeout()
   107  		Expect(session).Should(ExitCleanly())
   108  
   109  		_, ec, cid := podmanTest.RunLsContainer("test1")
   110  		Expect(ec).To(Equal(0))
   111  
   112  		latest := "-l"
   113  		if IsRemote() {
   114  			latest = cid
   115  		}
   116  		result := podmanTest.Podman([]string{"rm", latest})
   117  		result.WaitWithDefaultTimeout()
   118  		Expect(result).Should(ExitCleanly())
   119  		output := result.OutputToString()
   120  		Expect(output).To(ContainSubstring(cid))
   121  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   122  	})
   123  
   124  	It("podman rm --cidfile", func() {
   125  		tmpDir := GinkgoT().TempDir()
   126  		tmpFile := tmpDir + "cid"
   127  
   128  		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "ls"})
   129  		session.WaitWithDefaultTimeout()
   130  		Expect(session).Should(ExitCleanly())
   131  		cid := session.OutputToStringArray()[0]
   132  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   133  
   134  		result := podmanTest.Podman([]string{"rm", "--cidfile", tmpFile})
   135  		result.WaitWithDefaultTimeout()
   136  		Expect(result).Should(ExitCleanly())
   137  		output := result.OutputToString()
   138  		Expect(output).To(ContainSubstring(cid))
   139  		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
   140  	})
   141  
   142  	It("podman rm multiple --cidfile", func() {
   143  		tmpDir := GinkgoT().TempDir()
   144  		tmpFile1 := tmpDir + "cid-1"
   145  		tmpFile2 := tmpDir + "cid-2"
   146  
   147  		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile1, ALPINE, "ls"})
   148  		session.WaitWithDefaultTimeout()
   149  		Expect(session).Should(ExitCleanly())
   150  		cid1 := session.OutputToStringArray()[0]
   151  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   152  
   153  		session = podmanTest.Podman([]string{"create", "--cidfile", tmpFile2, ALPINE, "ls"})
   154  		session.WaitWithDefaultTimeout()
   155  		Expect(session).Should(ExitCleanly())
   156  		cid2 := session.OutputToStringArray()[0]
   157  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   158  
   159  		result := podmanTest.Podman([]string{"rm", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
   160  		result.WaitWithDefaultTimeout()
   161  		Expect(result).Should(ExitCleanly())
   162  		output := result.OutputToString()
   163  		Expect(output).To(ContainSubstring(cid1))
   164  		Expect(output).To(ContainSubstring(cid2))
   165  		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
   166  	})
   167  
   168  	It("podman rm invalid --latest and --cidfile and --all", func() {
   169  		SkipIfRemote("Verifying --latest flag")
   170  
   171  		result := podmanTest.Podman([]string{"rm", "--cidfile", "foobar", "--latest"})
   172  		result.WaitWithDefaultTimeout()
   173  		Expect(result).Should(Exit(125))
   174  		Expect(result.ErrorToString()).To(ContainSubstring("--all, --latest, and --cidfile cannot be used together"))
   175  
   176  		result = podmanTest.Podman([]string{"rm", "--cidfile", "foobar", "--all"})
   177  		result.WaitWithDefaultTimeout()
   178  		Expect(result).Should(Exit(125))
   179  		Expect(result.ErrorToString()).To(ContainSubstring("--all, --latest, and --cidfile cannot be used together"))
   180  
   181  		result = podmanTest.Podman([]string{"rm", "--cidfile", "foobar", "--all", "--latest"})
   182  		result.WaitWithDefaultTimeout()
   183  		Expect(result).Should(Exit(125))
   184  		Expect(result.ErrorToString()).To(ContainSubstring("--all, --latest, and --cidfile cannot be used together"))
   185  
   186  		result = podmanTest.Podman([]string{"rm", "--latest", "--all"})
   187  		result.WaitWithDefaultTimeout()
   188  		Expect(result).Should(Exit(125))
   189  		Expect(result.ErrorToString()).To(ContainSubstring("--all and --latest cannot be used together"))
   190  	})
   191  
   192  	It("podman rm --all", func() {
   193  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   194  		session.WaitWithDefaultTimeout()
   195  		Expect(session).Should(ExitCleanly())
   196  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   197  
   198  		session = podmanTest.Podman([]string{"create", ALPINE, "ls"})
   199  		session.WaitWithDefaultTimeout()
   200  		Expect(session).Should(ExitCleanly())
   201  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   202  
   203  		session = podmanTest.Podman([]string{"rm", "--all"})
   204  		session.WaitWithDefaultTimeout()
   205  		Expect(session).Should(ExitCleanly())
   206  		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
   207  	})
   208  
   209  	It("podman rm --ignore", func() {
   210  		session := podmanTest.Podman([]string{"create", ALPINE, "ls"})
   211  		session.WaitWithDefaultTimeout()
   212  		Expect(session).Should(ExitCleanly())
   213  		cid := session.OutputToStringArray()[0]
   214  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   215  
   216  		session = podmanTest.Podman([]string{"rm", "bogus", cid})
   217  		session.WaitWithDefaultTimeout()
   218  		Expect(session).Should(Exit(1))
   219  		Expect(session.ErrorToString()).To(ContainSubstring("\"bogus\" found: no such container"))
   220  		if IsRemote() {
   221  			Expect(session.OutputToString()).To(BeEquivalentTo(cid))
   222  		}
   223  
   224  		session = podmanTest.Podman([]string{"rm", "--ignore", "bogus", cid})
   225  		session.WaitWithDefaultTimeout()
   226  		Expect(session).Should(ExitCleanly())
   227  		if !IsRemote() {
   228  			Expect(session.OutputToString()).To(BeEquivalentTo(cid))
   229  		}
   230  		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
   231  	})
   232  
   233  	It("podman rm bogus container", func() {
   234  		session := podmanTest.Podman([]string{"rm", "bogus"})
   235  		session.WaitWithDefaultTimeout()
   236  		Expect(session).Should(Exit(1))
   237  		Expect(session.ErrorToString()).To(ContainSubstring("\"bogus\" found: no such container"))
   238  	})
   239  
   240  	It("podman rm bogus container and a running container", func() {
   241  		session := podmanTest.RunTopContainer("test1")
   242  		session.WaitWithDefaultTimeout()
   243  		Expect(session).Should(ExitCleanly())
   244  
   245  		session = podmanTest.Podman([]string{"rm", "bogus", "test1"})
   246  		session.WaitWithDefaultTimeout()
   247  		Expect(session).Should(Exit(1))
   248  		Expect(session.ErrorToString()).To(ContainSubstring("\"bogus\" found: no such container"))
   249  
   250  		session = podmanTest.Podman([]string{"rm", "test1", "bogus"})
   251  		session.WaitWithDefaultTimeout()
   252  		Expect(session).Should(Exit(1))
   253  		Expect(session.ErrorToString()).To(ContainSubstring("\"bogus\" found: no such container"))
   254  	})
   255  
   256  	It("podman rm --ignore bogus container and a running container", func() {
   257  		session := podmanTest.RunTopContainer("test1")
   258  		session.WaitWithDefaultTimeout()
   259  		Expect(session).Should(ExitCleanly())
   260  
   261  		session = podmanTest.Podman([]string{"rm", "--ignore", "test1", "bogus"})
   262  		session.WaitWithDefaultTimeout()
   263  		Expect(session).Should(Exit(2))
   264  		Expect(session.ErrorToString()).To(ContainSubstring("containers cannot be removed without force"))
   265  
   266  		session = podmanTest.Podman([]string{"rm", "-t", "0", "--force", "--ignore", "bogus", "test1"})
   267  		session.WaitWithDefaultTimeout()
   268  		Expect(session).Should(ExitCleanly())
   269  		Expect(session.OutputToString()).To(BeEquivalentTo("test1"))
   270  	})
   271  
   272  	It("podman rm --filter", func() {
   273  		session1 := podmanTest.RunTopContainer("test1")
   274  		session1.WaitWithDefaultTimeout()
   275  		Expect(session1).Should(ExitCleanly())
   276  		cid1 := session1.OutputToString()
   277  
   278  		session1 = podmanTest.RunTopContainer("test2")
   279  		session1.WaitWithDefaultTimeout()
   280  		Expect(session1).Should(ExitCleanly())
   281  		cid2 := session1.OutputToString()
   282  
   283  		session1 = podmanTest.RunTopContainer("test3")
   284  		session1.WaitWithDefaultTimeout()
   285  		Expect(session1).Should(ExitCleanly())
   286  		cid3 := session1.OutputToString()
   287  		shortCid3 := cid3[0:5]
   288  
   289  		session1 = podmanTest.RunTopContainerWithArgs("test4", []string{"--label", "test=with,comma"})
   290  		session1.WaitWithDefaultTimeout()
   291  		Expect(session1).Should(ExitCleanly())
   292  		cid4 := session1.OutputToString()
   293  
   294  		session1 = podmanTest.Podman([]string{"rm", cid1, "-f", "--filter", "status=running"})
   295  		session1.WaitWithDefaultTimeout()
   296  		Expect(session1).Should(Exit(125))
   297  		Expect(session1.ErrorToString()).To(ContainSubstring("--filter takes no arguments"))
   298  
   299  		session1 = podmanTest.Podman([]string{"rm", "-a", "-f", "--filter", fmt.Sprintf("id=%swrongid", shortCid3)})
   300  		session1.WaitWithDefaultTimeout()
   301  		Expect(session1).Should(ExitCleanly())
   302  		Expect(session1.OutputToString()).To(BeEmpty())
   303  
   304  		session1 = podmanTest.Podman([]string{"rm", "-a", "-f", "--filter", fmt.Sprintf("id=%s", shortCid3)})
   305  		session1.WaitWithDefaultTimeout()
   306  		Expect(session1).Should(ExitCleanly())
   307  		Expect(session1.OutputToString()).To(BeEquivalentTo(cid3))
   308  
   309  		session1 = podmanTest.Podman([]string{"rm", "-f", "--filter", fmt.Sprintf("id=%s", cid2)})
   310  		session1.WaitWithDefaultTimeout()
   311  		Expect(session1).Should(ExitCleanly())
   312  		Expect(session1.OutputToString()).To(BeEquivalentTo(cid2))
   313  
   314  		session1 = podmanTest.Podman([]string{"rm", "-f", "--filter", "label=test=with,comma"})
   315  		session1.WaitWithDefaultTimeout()
   316  		Expect(session1).Should(ExitCleanly())
   317  		Expect(session1.OutputToString()).To(BeEquivalentTo(cid4))
   318  	})
   319  
   320  	It("podman rm -fa with dependencies", func() {
   321  		ctr1Name := "ctr1"
   322  		ctr1 := podmanTest.RunTopContainer(ctr1Name)
   323  		ctr1.WaitWithDefaultTimeout()
   324  		Expect(ctr1).Should(ExitCleanly())
   325  		cid1 := ctr1.OutputToString()
   326  
   327  		ctr2 := podmanTest.Podman([]string{"run", "-d", "--network", fmt.Sprintf("container:%s", ctr1Name), ALPINE, "top"})
   328  		ctr2.WaitWithDefaultTimeout()
   329  		Expect(ctr2).Should(ExitCleanly())
   330  		cid2 := ctr2.OutputToString()
   331  
   332  		rm := podmanTest.Podman([]string{"rm", "-fa"})
   333  		rm.WaitWithDefaultTimeout()
   334  		Expect(rm).Should(ExitCleanly())
   335  		Expect(rm.ErrorToString()).To(BeEmpty(), "rm -fa error logged")
   336  		Expect(rm.OutputToStringArray()).Should(ConsistOf(cid1, cid2))
   337  
   338  		Expect(podmanTest.NumberOfContainers()).To(Equal(0))
   339  	})
   340  })