mirror of
https://github.com/containers/podman.git
synced 2025-11-02 14:55:28 +08:00
547fff2703
e2e test failures are rife with messages like:
Expected 1 to equal 0
These make me cry. They're anti-helpful, requiring the reader
to dive into the source code to figure out what those numbers
mean.
Solution: Go tests have a '.Should(Exit(NNN))' mechanism. I
don't know if it spits out a better diagnostic (I have no way
to run e2e tests on my laptop), but I have to fantasize that
it will, and given the state of our flakes I assume that at
least one test will fail and give me the opportunity to see
what the error message looks like.
THIS IS NOT REVIEWABLE CODE. There is no way for a human
to review it. Don't bother. Maybe look at a few random
ones for sanity. If you want to really review, here is
a reproducer of what I did:
cd test/e2e
! positive assertions. The second is the same as the first,
! with the addition of (unnecessary) parentheses because
! some invocations were written that way. The third is BeZero().
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.To\(Equal\((\d+)\)\)/Expect($1).Should(Exit($2))/' *_test.go
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.To\(\(Equal\((\d+)\)\)\)/Expect($1).Should(Exit($2))/' *_test.go
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.To\(BeZero\(\)\)/Expect($1).Should(Exit(0))/' *_test.go
! Same as above, but handles three non-numeric exit codes
! in run_exit_test.go
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.To\(Equal\((\S+)\)\)/Expect($1).Should(Exit($2))/' *_test.go
! negative assertions. Difference is the spelling of 'To(Not)',
! 'ToNot', and 'NotTo'. I assume those are all the same.
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.To\(Not\(Equal\((0)\)\)\)/Expect($1).To(ExitWithError())/' *_test.go
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.ToNot\(Equal\((0)\)\)/Expect($1).To(ExitWithError())/' *_test.go
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.NotTo\(Equal\((0)\)\)/Expect($1).To(ExitWithError())/' *_test.go
! negative, old use of BeZero()
perl -pi -e 's/Expect\((\S+)\.ExitCode\(\)\)\.ToNot\(BeZero\(\)\)/Expect($1).Should(ExitWithError())/' *_test.go
Run those on a clean copy of main branch (at the same branch
point as my PR, of course), then diff against a checked-out
copy of my PR. There should be no differences. Then all you
have to review is that my replacements above are sane.
UPDATE: nope, that's not enough, you also need to add gomega/gexec
to the files that don't have it:
perl -pi -e '$_ .= "$1/gexec\"\n" if m!^(.*/onsi/gomega)"!' $(grep -L gomega/gexec $(git log -1 --stat | awk '$1 ~ /test\/e2e\// { print $1}'))
UPDATE 2: hand-edit run_volume_test.go
UPDATE 3: sigh, add WaitWithDefaultTimeout() to a couple of places
UPDATE 4: skip a test due to bug #10935 (race condition)
Signed-off-by: Ed Santiago <santiago@redhat.com>
395 lines
14 KiB
Go
395 lines
14 KiB
Go
package integration
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
. "github.com/containers/podman/v3/test/utils"
|
|
. "github.com/onsi/ginkgo"
|
|
. "github.com/onsi/gomega"
|
|
. "github.com/onsi/gomega/gexec"
|
|
)
|
|
|
|
var _ = Describe("Podman run", func() {
|
|
var (
|
|
tempdir string
|
|
err error
|
|
podmanTest *PodmanTestIntegration
|
|
)
|
|
|
|
BeforeEach(func() {
|
|
tempdir, err = CreateTempDirInTempDir()
|
|
if err != nil {
|
|
os.Exit(1)
|
|
}
|
|
podmanTest = PodmanTestCreate(tempdir)
|
|
podmanTest.Setup()
|
|
podmanTest.SeedImages()
|
|
os.Setenv("CONTAINERS_CONF", "config/containers.conf")
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
|
|
})
|
|
|
|
AfterEach(func() {
|
|
podmanTest.Cleanup()
|
|
f := CurrentGinkgoTestDescription()
|
|
processTestResult(f)
|
|
os.Unsetenv("CONTAINERS_CONF")
|
|
})
|
|
|
|
It("podman run limits test", func() {
|
|
SkipIfRootlessCgroupsV1("Setting limits not supported on cgroupv1 for rootless users")
|
|
//containers.conf is set to "nofile=500:500"
|
|
session := podmanTest.Podman([]string{"run", "--rm", fedoraMinimal, "ulimit", "-n"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("500"))
|
|
|
|
session = podmanTest.Podman([]string{"run", "--rm", "--ulimit", "nofile=2048:2048", fedoraMinimal, "ulimit", "-n"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("2048"))
|
|
})
|
|
|
|
It("podman run with containers.conf having additional env", func() {
|
|
//containers.conf default env includes foo
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "printenv"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("foo=bar"))
|
|
})
|
|
|
|
It("podman run with additional devices", func() {
|
|
//containers.conf devices includes notone
|
|
session := podmanTest.Podman([]string{"run", "--device", "/dev/null:/dev/bar", ALPINE, "ls", "/dev"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("bar"))
|
|
Expect(session.OutputToString()).To(ContainSubstring("notone"))
|
|
})
|
|
|
|
It("podman run shm-size", func() {
|
|
//containers.conf default sets shm-size=201k, which ends up as 200k
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "grep", "shm", "/proc/self/mounts"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("size=200k"))
|
|
})
|
|
|
|
It("podman Capabilities in containers.conf", func() {
|
|
SkipIfRootlessCgroupsV1("Not supported for rootless + CGroupsV1")
|
|
cap := podmanTest.Podman([]string{"run", ALPINE, "grep", "CapEff", "/proc/self/status"})
|
|
cap.WaitWithDefaultTimeout()
|
|
Expect(cap).Should(Exit(0))
|
|
|
|
os.Setenv("CONTAINERS_CONF", "config/containers-ns.conf")
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
session := podmanTest.Podman([]string{"run", BB, "grep", "CapEff", "/proc/self/status"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).ToNot(Equal(cap.OutputToString()))
|
|
})
|
|
|
|
It("podman Regular capabilities", func() {
|
|
setup := podmanTest.RunTopContainer("test1")
|
|
setup.WaitWithDefaultTimeout()
|
|
result := podmanTest.Podman([]string{"top", "test1", "capeff"})
|
|
result.WaitWithDefaultTimeout()
|
|
Expect(result).Should(Exit(0))
|
|
Expect(result.OutputToString()).To(ContainSubstring("SYS_CHROOT"))
|
|
Expect(result.OutputToString()).To(ContainSubstring("NET_RAW"))
|
|
})
|
|
|
|
It("podman drop capabilities", func() {
|
|
os.Setenv("CONTAINERS_CONF", "config/containers-caps.conf")
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
setup := podmanTest.RunTopContainer("test1")
|
|
setup.WaitWithDefaultTimeout()
|
|
result := podmanTest.Podman([]string{"container", "top", "test1", "capeff"})
|
|
result.WaitWithDefaultTimeout()
|
|
Expect(result).Should(Exit(0))
|
|
Expect(result.OutputToString()).ToNot(ContainSubstring("SYS_CHROOT"))
|
|
Expect(result.OutputToString()).ToNot(ContainSubstring("NET_RAW"))
|
|
})
|
|
|
|
verifyNSHandling := func(nspath, option string) {
|
|
SkipIfRootlessCgroupsV1("Not supported for rootless + CGroupsV1")
|
|
os.Setenv("CONTAINERS_CONF", "config/containers-ns.conf")
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
//containers.conf default ipcns to default to host
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "ls", "-l", nspath})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
fields := strings.Split(session.OutputToString(), " ")
|
|
ctrNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
|
|
|
|
cmd := exec.Command("ls", "-l", nspath)
|
|
res, err := cmd.Output()
|
|
Expect(err).To(BeNil())
|
|
fields = strings.Split(string(res), " ")
|
|
hostNS := strings.TrimSuffix(fields[len(fields)-1], "\n")
|
|
Expect(hostNS).To(Equal(ctrNS))
|
|
|
|
session = podmanTest.Podman([]string{"run", option, "private", ALPINE, "ls", "-l", nspath})
|
|
fields = strings.Split(session.OutputToString(), " ")
|
|
ctrNS = fields[len(fields)-1]
|
|
Expect(hostNS).ToNot(Equal(ctrNS))
|
|
}
|
|
|
|
It("podman compare netns", func() {
|
|
verifyNSHandling("/proc/self/ns/net", "--network")
|
|
})
|
|
|
|
It("podman compare ipcns", func() {
|
|
verifyNSHandling("/proc/self/ns/ipc", "--ipc")
|
|
})
|
|
|
|
It("podman compare utsns", func() {
|
|
verifyNSHandling("/proc/self/ns/uts", "--uts")
|
|
})
|
|
|
|
It("podman compare pidns", func() {
|
|
verifyNSHandling("/proc/self/ns/pid", "--pid")
|
|
})
|
|
|
|
It("podman compare cgroupns", func() {
|
|
verifyNSHandling("/proc/self/ns/cgroup", "--cgroupns")
|
|
})
|
|
|
|
It("using journald for container with container log_tag", func() {
|
|
SkipIfInContainer("journalctl inside a container doesn't work correctly")
|
|
os.Setenv("CONTAINERS_CONF", "config/containers-journald.conf")
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
logc := podmanTest.Podman([]string{"run", "-d", ALPINE, "sh", "-c", "echo podman; sleep 0.1; echo podman; sleep 0.1; echo podman"})
|
|
logc.WaitWithDefaultTimeout()
|
|
Expect(logc).Should(Exit(0))
|
|
cid := logc.OutputToString()
|
|
|
|
wait := podmanTest.Podman([]string{"wait", cid})
|
|
wait.WaitWithDefaultTimeout()
|
|
Expect(wait).Should(Exit(0))
|
|
|
|
cmd := exec.Command("journalctl", "--no-pager", "-o", "json", "--output-fields=CONTAINER_TAG", fmt.Sprintf("CONTAINER_ID_FULL=%s", cid))
|
|
out, err := cmd.CombinedOutput()
|
|
Expect(err).To(BeNil())
|
|
Expect(string(out)).To(ContainSubstring("alpine"))
|
|
})
|
|
|
|
It("podman containers.conf additionalvolumes", func() {
|
|
conffile := filepath.Join(podmanTest.TempDir, "container.conf")
|
|
tempdir, err = CreateTempDirInTempDir()
|
|
Expect(err).To(BeNil())
|
|
|
|
err := ioutil.WriteFile(conffile, []byte(fmt.Sprintf("[containers]\nvolumes=[\"%s:%s:Z\",]\n", tempdir, tempdir)), 0755)
|
|
Expect(err).To(BeNil())
|
|
|
|
os.Setenv("CONTAINERS_CONF", conffile)
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
result := podmanTest.Podman([]string{"run", ALPINE, "ls", tempdir})
|
|
result.WaitWithDefaultTimeout()
|
|
Expect(result).Should(Exit(0))
|
|
})
|
|
|
|
It("podman run containers.conf sysctl test", func() {
|
|
//containers.conf is set to "net.ipv4.ping_group_range=0 1000"
|
|
session := podmanTest.Podman([]string{"run", "--rm", fedoraMinimal, "cat", "/proc/sys/net/ipv4/ping_group_range"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("1000"))
|
|
|
|
// Ignore containers.conf setting if --net=host
|
|
session = podmanTest.Podman([]string{"run", "--rm", "--net", "host", fedoraMinimal, "cat", "/proc/sys/net/ipv4/ping_group_range"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).ToNot((ContainSubstring("1000")))
|
|
})
|
|
|
|
It("podman run containers.conf search domain", func() {
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
session.LineInOutputStartsWith("search foobar.com")
|
|
})
|
|
|
|
It("podman run add dns server", func() {
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
session.LineInOutputStartsWith("server 1.2.3.4")
|
|
})
|
|
|
|
It("podman run add dns option", func() {
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
session.LineInOutputStartsWith("options debug")
|
|
})
|
|
|
|
It("podman run containers.conf remove all search domain", func() {
|
|
session := podmanTest.Podman([]string{"run", "--dns-search=.", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.LineInOutputStartsWith("search")).To(BeFalse())
|
|
})
|
|
|
|
It("podman run use containers.conf search domain", func() {
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.LineInOutputStartsWith("search")).To(BeTrue())
|
|
Expect(session.OutputToString()).To(ContainSubstring("foobar.com"))
|
|
|
|
Expect(session.OutputToString()).To(ContainSubstring("1.2.3.4"))
|
|
Expect(session.OutputToString()).To(ContainSubstring("debug"))
|
|
})
|
|
|
|
It("podman run containers.conf timezone", func() {
|
|
//containers.conf timezone set to Pacific/Honolulu
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "date", "+'%H %Z'"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("HST"))
|
|
})
|
|
|
|
It("podman run containers.conf umask", func() {
|
|
//containers.conf umask set to 0002
|
|
if !strings.Contains(podmanTest.OCIRuntime, "crun") {
|
|
Skip("Test only works on crun")
|
|
}
|
|
|
|
session := podmanTest.Podman([]string{"run", "--rm", ALPINE, "sh", "-c", "umask"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Equal("0002"))
|
|
})
|
|
|
|
It("podman set network cmd options slirp options to allow host loopback", func() {
|
|
session := podmanTest.Podman([]string{"run", "--network", "slirp4netns", ALPINE, "ping", "-c1", "10.0.2.2"})
|
|
session.Wait(30)
|
|
Expect(session).Should(Exit(0))
|
|
})
|
|
|
|
It("podman-remote test localcontainers.conf versus remote containers.conf", func() {
|
|
if !IsRemote() {
|
|
Skip("this test is only for remote")
|
|
}
|
|
|
|
os.Setenv("CONTAINERS_CONF", "config/containers-remote.conf")
|
|
// Configuration that comes from remote server
|
|
// env
|
|
session := podmanTest.Podman([]string{"run", ALPINE, "printenv", "foo"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Equal("bar"))
|
|
|
|
// dns-search, server, options
|
|
session = podmanTest.Podman([]string{"run", ALPINE, "cat", "/etc/resolv.conf"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.LineInOutputStartsWith("search")).To(BeTrue())
|
|
Expect(session.OutputToString()).To(ContainSubstring("foobar.com"))
|
|
Expect(session.OutputToString()).To(ContainSubstring("1.2.3.4"))
|
|
Expect(session.OutputToString()).To(ContainSubstring("debug"))
|
|
|
|
// sysctls
|
|
session = podmanTest.Podman([]string{"run", "--rm", ALPINE, "cat", "/proc/sys/net/ipv4/ping_group_range"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("1000"))
|
|
|
|
// shm-size
|
|
session = podmanTest.Podman([]string{"run", ALPINE, "grep", "shm", "/proc/self/mounts"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("size=200k"))
|
|
|
|
// ulimits
|
|
session = podmanTest.Podman([]string{"run", "--rm", fedoraMinimal, "ulimit", "-n"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("500"))
|
|
|
|
// Configuration that comes from remote client
|
|
// Timezone
|
|
session = podmanTest.Podman([]string{"run", ALPINE, "date", "+'%H %Z'"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Or(ContainSubstring("EST"), ContainSubstring("EDT")))
|
|
|
|
// Umask
|
|
session = podmanTest.Podman([]string{"run", "--rm", ALPINE, "sh", "-c", "umask"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Equal("0022"))
|
|
})
|
|
|
|
It("podman run containers.conf annotations test", func() {
|
|
//containers.conf is set to "run.oci.keep_original_groups=1"
|
|
session := podmanTest.Podman([]string{"create", "--rm", "--name", "test", fedoraMinimal})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
|
|
inspect := podmanTest.Podman([]string{"inspect", "--format", "{{ .Config.Annotations }}", "test"})
|
|
inspect.WaitWithDefaultTimeout()
|
|
Expect(inspect.OutputToString()).To(ContainSubstring("run.oci.keep_original_groups:1"))
|
|
})
|
|
|
|
It("podman run with --add-host and no-hosts=true fails", func() {
|
|
session := podmanTest.Podman([]string{"run", "-dt", "--add-host", "test1:127.0.0.1", ALPINE, "top"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).To(ExitWithError())
|
|
Expect(session.ErrorToString()).To(ContainSubstring("--no-hosts and --add-host cannot be set together"))
|
|
|
|
session = podmanTest.Podman([]string{"run", "-dt", "--add-host", "test1:127.0.0.1", "--no-hosts=false", ALPINE, "top"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
})
|
|
|
|
It("podman run with no-hosts=true /etc/hosts does not include hostname", func() {
|
|
session := podmanTest.Podman([]string{"run", "--rm", "--name", "test", ALPINE, "cat", "/etc/hosts"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Not(ContainSubstring("test")))
|
|
|
|
session = podmanTest.Podman([]string{"run", "--rm", "--name", "test", "--no-hosts=false", ALPINE, "cat", "/etc/hosts"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(ContainSubstring("test"))
|
|
})
|
|
|
|
It("podman info seccomp profile path", func() {
|
|
configPath := filepath.Join(podmanTest.TempDir, "containers.conf")
|
|
os.Setenv("CONTAINERS_CONF", configPath)
|
|
|
|
profile := filepath.Join(podmanTest.TempDir, "seccomp.json")
|
|
containersConf := []byte(fmt.Sprintf("[containers]\nseccomp_profile=\"%s\"", profile))
|
|
err = ioutil.WriteFile(configPath, containersConf, os.ModePerm)
|
|
Expect(err).To(BeNil())
|
|
|
|
if IsRemote() {
|
|
podmanTest.RestartRemoteService()
|
|
}
|
|
|
|
session := podmanTest.Podman([]string{"info", "--format", "{{.Host.Security.SECCOMPProfilePath}}"})
|
|
session.WaitWithDefaultTimeout()
|
|
Expect(session).Should(Exit(0))
|
|
Expect(session.OutputToString()).To(Equal(profile))
|
|
})
|
|
})
|