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

     1  package integration
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"strings"
     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 stop", 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.SeedImages()
    29  	})
    30  
    31  	AfterEach(func() {
    32  		podmanTest.Cleanup()
    33  		f := CurrentGinkgoTestDescription()
    34  		processTestResult(f)
    35  
    36  	})
    37  
    38  	It("podman stop bogus container", func() {
    39  		session := podmanTest.Podman([]string{"stop", "foobar"})
    40  		session.WaitWithDefaultTimeout()
    41  		Expect(session).Should(Exit(125))
    42  	})
    43  
    44  	It("podman stop --ignore bogus container", func() {
    45  		session := podmanTest.RunTopContainer("")
    46  		session.WaitWithDefaultTimeout()
    47  		Expect(session).Should(Exit(0))
    48  		cid := session.OutputToString()
    49  
    50  		session = podmanTest.Podman([]string{"stop", "--ignore", "foobar", cid})
    51  		session.WaitWithDefaultTimeout()
    52  		Expect(session).Should(Exit(0))
    53  		output := session.OutputToString()
    54  		Expect(output).To(ContainSubstring(cid))
    55  	})
    56  
    57  	It("podman stop container by id", func() {
    58  		session := podmanTest.RunTopContainer("")
    59  		session.WaitWithDefaultTimeout()
    60  		Expect(session).Should(Exit(0))
    61  		cid := session.OutputToString()
    62  		session = podmanTest.Podman([]string{"stop", cid})
    63  		session.WaitWithDefaultTimeout()
    64  		Expect(session).Should(Exit(0))
    65  
    66  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    67  		finalCtrs.WaitWithDefaultTimeout()
    68  		Expect(finalCtrs).Should(Exit(0))
    69  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    70  	})
    71  
    72  	It("podman stop container by name", func() {
    73  		session := podmanTest.RunTopContainer("test1")
    74  		session.WaitWithDefaultTimeout()
    75  		Expect(session).Should(Exit(0))
    76  		session = podmanTest.Podman([]string{"stop", "test1"})
    77  		session.WaitWithDefaultTimeout()
    78  		Expect(session).Should(Exit(0))
    79  
    80  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    81  		finalCtrs.WaitWithDefaultTimeout()
    82  		Expect(finalCtrs).Should(Exit(0))
    83  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    84  	})
    85  
    86  	It("podman container stop by name", func() {
    87  		session := podmanTest.RunTopContainer("test1")
    88  		session.WaitWithDefaultTimeout()
    89  		Expect(session).Should(Exit(0))
    90  		session = podmanTest.Podman([]string{"container", "stop", "test1"})
    91  		session.WaitWithDefaultTimeout()
    92  		Expect(session).Should(Exit(0))
    93  
    94  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
    95  		finalCtrs.WaitWithDefaultTimeout()
    96  		Expect(finalCtrs).Should(Exit(0))
    97  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
    98  	})
    99  
   100  	It("podman stop stopped container", func() {
   101  		session := podmanTest.RunTopContainer("test1")
   102  		session.WaitWithDefaultTimeout()
   103  		Expect(session).Should(Exit(0))
   104  
   105  		session2 := podmanTest.Podman([]string{"stop", "test1"})
   106  		session2.WaitWithDefaultTimeout()
   107  		Expect(session2).Should(Exit(0))
   108  
   109  		session3 := podmanTest.Podman([]string{"stop", "test1"})
   110  		session3.WaitWithDefaultTimeout()
   111  		Expect(session3).Should(Exit(0))
   112  
   113  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   114  		finalCtrs.WaitWithDefaultTimeout()
   115  		Expect(finalCtrs).Should(Exit(0))
   116  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   117  	})
   118  
   119  	It("podman stop all containers -t", func() {
   120  		session := podmanTest.RunTopContainer("test1")
   121  		session.WaitWithDefaultTimeout()
   122  		Expect(session).Should(Exit(0))
   123  		cid1 := session.OutputToString()
   124  
   125  		session = podmanTest.RunTopContainer("test2")
   126  		session.WaitWithDefaultTimeout()
   127  		Expect(session).Should(Exit(0))
   128  		cid2 := session.OutputToString()
   129  
   130  		session = podmanTest.RunTopContainer("test3")
   131  		session.WaitWithDefaultTimeout()
   132  		Expect(session).Should(Exit(0))
   133  		cid3 := session.OutputToString()
   134  
   135  		session = podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   136  		session.WaitWithDefaultTimeout()
   137  		Expect(session).Should(Exit(0))
   138  		output := session.OutputToString()
   139  		Expect(output).To(ContainSubstring(cid1))
   140  		Expect(output).To(ContainSubstring(cid2))
   141  		Expect(output).To(ContainSubstring(cid3))
   142  
   143  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   144  		finalCtrs.WaitWithDefaultTimeout()
   145  		Expect(finalCtrs).Should(Exit(0))
   146  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   147  	})
   148  
   149  	It("podman stop container --time", func() {
   150  		session := podmanTest.RunTopContainer("test4")
   151  		session.WaitWithDefaultTimeout()
   152  		Expect(session).Should(Exit(0))
   153  
   154  		session = podmanTest.Podman([]string{"stop", "--time", "0", "test4"})
   155  		session.WaitWithDefaultTimeout()
   156  		Expect(session).Should(Exit(0))
   157  		output := session.OutputToString()
   158  		Expect(output).To(ContainSubstring("test4"))
   159  
   160  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   161  		finalCtrs.WaitWithDefaultTimeout()
   162  		Expect(finalCtrs).Should(Exit(0))
   163  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   164  	})
   165  
   166  	It("podman stop container --timeout", func() {
   167  		session := podmanTest.Podman([]string{"run", "-d", "--name", "test5", ALPINE, "sleep", "100"})
   168  		session.WaitWithDefaultTimeout()
   169  		Expect(session).Should(Exit(0))
   170  		session = podmanTest.Podman([]string{"stop", "--timeout", "0", "test5"})
   171  		// Without timeout container stops in 10 seconds
   172  		// If not stopped in 5 seconds, then --timeout did not work
   173  		session.Wait(5)
   174  		Expect(session).Should(Exit(0))
   175  		output := session.OutputToString()
   176  		Expect(output).To(ContainSubstring("test5"))
   177  
   178  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   179  		finalCtrs.WaitWithDefaultTimeout()
   180  		Expect(finalCtrs).Should(Exit(0))
   181  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   182  	})
   183  
   184  	It("podman stop latest containers", func() {
   185  		SkipIfRemote("--latest flag n/a")
   186  		session := podmanTest.RunTopContainer("test1")
   187  		session.WaitWithDefaultTimeout()
   188  		Expect(session).Should(Exit(0))
   189  		session = podmanTest.Podman([]string{"stop", "-l", "-t", "1"})
   190  		session.WaitWithDefaultTimeout()
   191  		Expect(session).Should(Exit(0))
   192  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   193  		finalCtrs.WaitWithDefaultTimeout()
   194  		Expect(finalCtrs).Should(Exit(0))
   195  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   196  	})
   197  
   198  	It("podman stop all containers with one stopped", func() {
   199  		session := podmanTest.RunTopContainer("test1")
   200  		session.WaitWithDefaultTimeout()
   201  		Expect(session).Should(Exit(0))
   202  		session2 := podmanTest.RunTopContainer("test2")
   203  		session2.WaitWithDefaultTimeout()
   204  		Expect(session2).Should(Exit(0))
   205  		cid := "-l"
   206  		if IsRemote() {
   207  			cid = "test2"
   208  		}
   209  		session3 := podmanTest.Podman([]string{"stop", cid, "-t", "1"})
   210  		session3.WaitWithDefaultTimeout()
   211  		Expect(session3).Should(Exit(0))
   212  		session4 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   213  		session4.WaitWithDefaultTimeout()
   214  		Expect(session4).Should(Exit(0))
   215  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   216  		finalCtrs.WaitWithDefaultTimeout()
   217  		Expect(finalCtrs).Should(Exit(0))
   218  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   219  	})
   220  
   221  	It("podman stop all containers with one created", func() {
   222  		session := podmanTest.RunTopContainer("test1")
   223  		session.WaitWithDefaultTimeout()
   224  		Expect(session).Should(Exit(0))
   225  		session2 := podmanTest.Podman([]string{"create", ALPINE, "/bin/sh"})
   226  		session2.WaitWithDefaultTimeout()
   227  		Expect(session2).Should(Exit(0))
   228  		session3 := podmanTest.Podman([]string{"stop", "-a", "-t", "1"})
   229  		session3.WaitWithDefaultTimeout()
   230  		Expect(session3).Should(Exit(0))
   231  		finalCtrs := podmanTest.Podman([]string{"ps", "-q"})
   232  		finalCtrs.WaitWithDefaultTimeout()
   233  		Expect(finalCtrs).Should(Exit(0))
   234  		Expect(strings.TrimSpace(finalCtrs.OutputToString())).To(Equal(""))
   235  	})
   236  
   237  	It("podman stop should return silent success on stopping configured containers", func() {
   238  		// following container is not created on OCI runtime
   239  		// so we return success and assume that is is stopped
   240  		session2 := podmanTest.Podman([]string{"create", "--name", "stopctr", ALPINE, "/bin/sh"})
   241  		session2.WaitWithDefaultTimeout()
   242  		Expect(session2).Should(Exit(0))
   243  		session3 := podmanTest.Podman([]string{"stop", "stopctr"})
   244  		session3.WaitWithDefaultTimeout()
   245  		Expect(session3).Should(Exit(0))
   246  	})
   247  
   248  	It("podman stop --cidfile", func() {
   249  
   250  		tmpDir, err := ioutil.TempDir("", "")
   251  		Expect(err).To(BeNil())
   252  		tmpFile := tmpDir + "cid"
   253  
   254  		defer os.RemoveAll(tmpDir)
   255  
   256  		session := podmanTest.Podman([]string{"create", "--cidfile", tmpFile, ALPINE, "top"})
   257  		session.WaitWithDefaultTimeout()
   258  		Expect(session).Should(Exit(0))
   259  		cid := session.OutputToStringArray()[0]
   260  
   261  		session = podmanTest.Podman([]string{"start", cid})
   262  		session.WaitWithDefaultTimeout()
   263  		Expect(session).Should(Exit(0))
   264  
   265  		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile})
   266  		result.WaitWithDefaultTimeout()
   267  		Expect(result).Should(Exit(0))
   268  		output := result.OutputToString()
   269  		Expect(output).To(ContainSubstring(cid))
   270  	})
   271  
   272  	It("podman stop multiple --cidfile", func() {
   273  
   274  		tmpDir, err := ioutil.TempDir("", "")
   275  		Expect(err).To(BeNil())
   276  		tmpFile1 := tmpDir + "cid-1"
   277  		tmpFile2 := tmpDir + "cid-2"
   278  
   279  		defer os.RemoveAll(tmpDir)
   280  
   281  		session := podmanTest.Podman([]string{"run", "--cidfile", tmpFile1, "-d", ALPINE, "top"})
   282  		session.WaitWithDefaultTimeout()
   283  		Expect(session).Should(Exit(0))
   284  		cid1 := session.OutputToStringArray()[0]
   285  		Expect(podmanTest.NumberOfContainers()).To(Equal(1))
   286  
   287  		session = podmanTest.Podman([]string{"run", "--cidfile", tmpFile2, "-d", ALPINE, "top"})
   288  		session.WaitWithDefaultTimeout()
   289  		Expect(session).Should(Exit(0))
   290  		cid2 := session.OutputToStringArray()[0]
   291  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   292  
   293  		result := podmanTest.Podman([]string{"stop", "--cidfile", tmpFile1, "--cidfile", tmpFile2})
   294  		result.WaitWithDefaultTimeout()
   295  		Expect(result).Should(Exit(0))
   296  		output := result.OutputToString()
   297  		Expect(output).To(ContainSubstring(cid1))
   298  		Expect(output).To(ContainSubstring(cid2))
   299  		Expect(podmanTest.NumberOfContainers()).To(Equal(2))
   300  	})
   301  
   302  	It("podman stop invalid --latest and --cidfile and --all", func() {
   303  		SkipIfRemote("--latest flag n/a")
   304  
   305  		result := podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--latest"})
   306  		result.WaitWithDefaultTimeout()
   307  		Expect(result).Should(Exit(125))
   308  
   309  		result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all"})
   310  		result.WaitWithDefaultTimeout()
   311  		Expect(result).Should(Exit(125))
   312  
   313  		result = podmanTest.Podman([]string{"stop", "--cidfile", "foobar", "--all", "--latest"})
   314  		result.WaitWithDefaultTimeout()
   315  		Expect(result).Should(Exit(125))
   316  
   317  		result = podmanTest.Podman([]string{"stop", "--latest", "--all"})
   318  		result.WaitWithDefaultTimeout()
   319  		Expect(result).Should(Exit(125))
   320  	})
   321  
   322  	It("podman stop --all", func() {
   323  		session := podmanTest.RunTopContainer("")
   324  		session.WaitWithDefaultTimeout()
   325  		Expect(session).Should(Exit(0))
   326  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   327  
   328  		session = podmanTest.RunTopContainer("")
   329  		session.WaitWithDefaultTimeout()
   330  		Expect(session).Should(Exit(0))
   331  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(2))
   332  
   333  		session = podmanTest.Podman([]string{"stop", "--all"})
   334  		session.WaitWithDefaultTimeout()
   335  		Expect(session).Should(Exit(0))
   336  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
   337  	})
   338  
   339  	It("podman stop --ignore", func() {
   340  		session := podmanTest.RunTopContainer("")
   341  		session.WaitWithDefaultTimeout()
   342  		Expect(session).Should(Exit(0))
   343  		cid := session.OutputToString()
   344  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(1))
   345  
   346  		session = podmanTest.Podman([]string{"stop", "bogus", cid})
   347  		session.WaitWithDefaultTimeout()
   348  		Expect(session).Should(Exit(125))
   349  
   350  		session = podmanTest.Podman([]string{"stop", "--ignore", "bogus", cid})
   351  		session.WaitWithDefaultTimeout()
   352  		Expect(session).Should(Exit(0))
   353  		Expect(podmanTest.NumberOfContainersRunning()).To(Equal(0))
   354  	})
   355  })