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

     1  package integration
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"time"
     7  
     8  	define "github.com/containers/podman/v3/libpod/define"
     9  	. "github.com/containers/podman/v3/test/utils"
    10  	. "github.com/onsi/ginkgo"
    11  	. "github.com/onsi/gomega"
    12  	. "github.com/onsi/gomega/gexec"
    13  )
    14  
    15  var _ = Describe("Podman healthcheck run", func() {
    16  	var (
    17  		tempdir    string
    18  		err        error
    19  		podmanTest *PodmanTestIntegration
    20  	)
    21  
    22  	BeforeEach(func() {
    23  		tempdir, err = CreateTempDirInTempDir()
    24  		if err != nil {
    25  			os.Exit(1)
    26  		}
    27  		podmanTest = PodmanTestCreate(tempdir)
    28  		podmanTest.Setup()
    29  		podmanTest.SeedImages()
    30  	})
    31  
    32  	AfterEach(func() {
    33  		podmanTest.Cleanup()
    34  		f := CurrentGinkgoTestDescription()
    35  		timedResult := fmt.Sprintf("Test: %s completed in %f seconds", f.TestText, f.Duration.Seconds())
    36  		GinkgoWriter.Write([]byte(timedResult))
    37  
    38  	})
    39  
    40  	It("podman healthcheck run bogus container", func() {
    41  		session := podmanTest.Podman([]string{"healthcheck", "run", "foobar"})
    42  		session.WaitWithDefaultTimeout()
    43  		Expect(session).To(ExitWithError())
    44  	})
    45  
    46  	It("podman disable healthcheck with --no-healthcheck on valid container", func() {
    47  		session := podmanTest.Podman([]string{"run", "-dt", "--no-healthcheck", "--name", "hc", healthcheck})
    48  		session.WaitWithDefaultTimeout()
    49  		Expect(session).Should(Exit(0))
    50  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
    51  		hc.WaitWithDefaultTimeout()
    52  		Expect(hc).Should(Exit(125))
    53  	})
    54  
    55  	It("podman disable healthcheck with --health-cmd=none on valid container", func() {
    56  		session := podmanTest.Podman([]string{"run", "-dt", "--health-cmd", "none", "--name", "hc", healthcheck})
    57  		session.WaitWithDefaultTimeout()
    58  		Expect(session).Should(Exit(0))
    59  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
    60  		hc.WaitWithDefaultTimeout()
    61  		Expect(hc).Should(Exit(125))
    62  	})
    63  
    64  	It("podman healthcheck on valid container", func() {
    65  		Skip("Extremely consistent flake - re-enable on debugging")
    66  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", healthcheck})
    67  		session.WaitWithDefaultTimeout()
    68  		Expect(session).Should(Exit(0))
    69  
    70  		exitCode := 999
    71  
    72  		// Buy a little time to get container running
    73  		for i := 0; i < 5; i++ {
    74  			hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
    75  			hc.WaitWithDefaultTimeout()
    76  			exitCode = hc.ExitCode()
    77  			if exitCode == 0 || i == 4 {
    78  				break
    79  			}
    80  			time.Sleep(1 * time.Second)
    81  		}
    82  		Expect(exitCode).To(Equal(0))
    83  
    84  		ps := podmanTest.Podman([]string{"ps"})
    85  		ps.WaitWithDefaultTimeout()
    86  		Expect(ps).Should(Exit(0))
    87  		Expect(ps.OutputToString()).To(ContainSubstring("(healthy)"))
    88  	})
    89  
    90  	It("podman healthcheck that should fail", func() {
    91  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "quay.io/libpod/badhealthcheck:latest"})
    92  		session.WaitWithDefaultTimeout()
    93  		Expect(session).Should(Exit(0))
    94  
    95  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
    96  		hc.WaitWithDefaultTimeout()
    97  		Expect(hc).Should(Exit(1))
    98  	})
    99  
   100  	It("podman healthcheck on stopped container", func() {
   101  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", healthcheck, "ls"})
   102  		session.WaitWithDefaultTimeout()
   103  		Expect(session).Should(Exit(0))
   104  
   105  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   106  		hc.WaitWithDefaultTimeout()
   107  		Expect(hc).Should(Exit(125))
   108  	})
   109  
   110  	It("podman healthcheck on container without healthcheck", func() {
   111  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", ALPINE, "top"})
   112  		session.WaitWithDefaultTimeout()
   113  		Expect(session).Should(Exit(0))
   114  
   115  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   116  		hc.WaitWithDefaultTimeout()
   117  		Expect(hc).Should(Exit(125))
   118  	})
   119  
   120  	It("podman healthcheck should be starting", func() {
   121  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-retries", "2", "--health-cmd", "ls /foo || exit 1", ALPINE, "top"})
   122  		session.WaitWithDefaultTimeout()
   123  		Expect(session).Should(Exit(0))
   124  		inspect := podmanTest.InspectContainer("hc")
   125  		Expect(inspect[0].State.Healthcheck.Status).To(Equal("starting"))
   126  	})
   127  
   128  	It("podman healthcheck failed checks in start-period should not change status", func() {
   129  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-start-period", "2m", "--health-retries", "2", "--health-cmd", "ls /foo || exit 1", ALPINE, "top"})
   130  		session.WaitWithDefaultTimeout()
   131  		Expect(session).Should(Exit(0))
   132  
   133  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   134  		hc.WaitWithDefaultTimeout()
   135  		Expect(hc).Should(Exit(1))
   136  
   137  		hc = podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   138  		hc.WaitWithDefaultTimeout()
   139  		Expect(hc).Should(Exit(1))
   140  
   141  		hc = podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   142  		hc.WaitWithDefaultTimeout()
   143  		Expect(hc).Should(Exit(1))
   144  
   145  		inspect := podmanTest.InspectContainer("hc")
   146  		Expect(inspect[0].State.Healthcheck.Status).To(Equal("starting"))
   147  	})
   148  
   149  	It("podman healthcheck failed checks must reach retries before unhealthy ", func() {
   150  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-retries", "2", "--health-cmd", "ls /foo || exit 1", ALPINE, "top"})
   151  		session.WaitWithDefaultTimeout()
   152  		Expect(session).Should(Exit(0))
   153  
   154  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   155  		hc.WaitWithDefaultTimeout()
   156  		Expect(hc).Should(Exit(1))
   157  
   158  		inspect := podmanTest.InspectContainer("hc")
   159  		Expect(inspect[0].State.Healthcheck.Status).To(Equal("starting"))
   160  
   161  		hc = podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   162  		hc.WaitWithDefaultTimeout()
   163  		Expect(hc).Should(Exit(1))
   164  
   165  		inspect = podmanTest.InspectContainer("hc")
   166  		Expect(inspect[0].State.Healthcheck.Status).To(Equal(define.HealthCheckUnhealthy))
   167  
   168  	})
   169  
   170  	It("podman healthcheck good check results in healthy even in start-period", func() {
   171  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-start-period", "2m", "--health-retries", "2", "--health-cmd", "ls || exit 1", ALPINE, "top"})
   172  		session.WaitWithDefaultTimeout()
   173  		Expect(session).Should(Exit(0))
   174  
   175  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   176  		hc.WaitWithDefaultTimeout()
   177  		Expect(hc).Should(Exit(0))
   178  
   179  		inspect := podmanTest.InspectContainer("hc")
   180  		Expect(inspect[0].State.Healthcheck.Status).To(Equal(define.HealthCheckHealthy))
   181  	})
   182  
   183  	It("podman healthcheck unhealthy but valid arguments check", func() {
   184  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-retries", "2", "--health-cmd", "[\"ls\", \"/foo\"]", ALPINE, "top"})
   185  		session.WaitWithDefaultTimeout()
   186  		Expect(session).Should(Exit(0))
   187  
   188  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   189  		hc.WaitWithDefaultTimeout()
   190  		Expect(hc).Should(Exit(1))
   191  	})
   192  
   193  	It("podman healthcheck single healthy result changes failed to healthy", func() {
   194  		session := podmanTest.Podman([]string{"run", "-dt", "--name", "hc", "--health-retries", "2", "--health-cmd", "ls /foo || exit 1", ALPINE, "top"})
   195  		session.WaitWithDefaultTimeout()
   196  		Expect(session).Should(Exit(0))
   197  
   198  		hc := podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   199  		hc.WaitWithDefaultTimeout()
   200  		Expect(hc).Should(Exit(1))
   201  
   202  		inspect := podmanTest.InspectContainer("hc")
   203  		Expect(inspect[0].State.Healthcheck.Status).To(Equal("starting"))
   204  
   205  		hc = podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   206  		hc.WaitWithDefaultTimeout()
   207  		Expect(hc).Should(Exit(1))
   208  
   209  		inspect = podmanTest.InspectContainer("hc")
   210  		Expect(inspect[0].State.Healthcheck.Status).To(Equal(define.HealthCheckUnhealthy))
   211  
   212  		foo := podmanTest.Podman([]string{"exec", "hc", "touch", "/foo"})
   213  		foo.WaitWithDefaultTimeout()
   214  		Expect(foo).Should(Exit(0))
   215  
   216  		hc = podmanTest.Podman([]string{"healthcheck", "run", "hc"})
   217  		hc.WaitWithDefaultTimeout()
   218  		Expect(hc).Should(Exit(0))
   219  
   220  		inspect = podmanTest.InspectContainer("hc")
   221  		Expect(inspect[0].State.Healthcheck.Status).To(Equal(define.HealthCheckHealthy))
   222  
   223  		// Test podman ps --filter heath is working (#11687)
   224  		ps := podmanTest.Podman([]string{"ps", "--filter", "health=healthy"})
   225  		ps.WaitWithDefaultTimeout()
   226  		Expect(ps).Should(Exit(0))
   227  		Expect(len(ps.OutputToStringArray())).To(Equal(2))
   228  		Expect(ps.OutputToString()).To(ContainSubstring("hc"))
   229  	})
   230  })