Initial gingko work

This implements the ginkgo integration test framework for
podman.  As tests are migrated from bats to ginkgo, we will
still run both integration suites.  When a test is migrated,
we remove the tests from bats at that time.  All new tests
should be just for the ginkgo framework.

One exception is that we only run the ginkgo suit in the
travis/ubuntu environment.  The CentOS and Fedora PAPR nodes
will more than cover those.

Signed-off-by: baude <bbaude@redhat.com>

Closes: #261
Approved by: baude

5 files changed, 663 insertions, 0 deletions

diff --git a/test/e2e/info_test.go b/test/e2e/info_test.go
new file mode 100644
index 000000000..965dffaae
--- /dev/null
+++ b/test/e2e/info_test.go
@@ -0,0 +1,35 @@
+package integration
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Podman Info", func() {
+	var (
+		tempdir    string
+		err        error
+		podmanTest PodmanTest
+	)
+
+	BeforeEach(func() {
+		tempdir, err = CreateTempDirInTempDir()
+		if err != nil {
+			os.Exit(1)
+		}
+		podmanTest = PodmanCreate(tempdir)
+	})
+
+	AfterEach(func() {
+		podmanTest.Cleanup()
+	})
+
+	It("podman info json output", func() {
+		session := podmanTest.Podman([]string{"info", "--format=json"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+})
diff --git a/test/e2e/libpod_suite_test.go b/test/e2e/libpod_suite_test.go
new file mode 100644
index 000000000..2f541244c
--- /dev/null
+++ b/test/e2e/libpod_suite_test.go
@@ -0,0 +1,308 @@
+package integration
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/containers/image/copy"
+	"github.com/containers/image/signature"
+	"github.com/containers/image/storage"
+	"github.com/containers/image/transports/alltransports"
+	"github.com/containers/image/types"
+	sstorage "github.com/containers/storage"
+	"github.com/containers/storage/pkg/reexec"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/onsi/gomega/gexec"
+	"github.com/pkg/errors"
+)
+
+// - CRIO_ROOT=/var/tmp/checkout PODMAN_BINARY=/usr/bin/podman CONMON_BINARY=/usr/libexec/crio/conmon PAPR=1 sh .papr.sh
+// PODMAN_OPTIONS="--root $TESTDIR/crio $STORAGE_OPTIONS --runroot $TESTDIR/crio-run --runtime ${RUNTIME_BINARY} --conmon ${CONMON_BINARY} --cni-config-dir ${LIBPOD_CNI_CONFIG}"
+
+//TODO do the image caching
+// "$COPYIMG_BINARY" --root "$TESTDIR/crio" $STORAGE_OPTIONS --runroot "$TESTDIR/crio-run" --image-name=${IMAGES[${key}]} --import-from=dir:"$ARTIFACTS_PATH"/${key} --add-name=${IMAGES[${key}]}
+//TODO whats the best way to clean up after a test
+
+var (
+	PODMAN_BINARY    string
+	CONMON_BINARY    string
+	CNI_CONFIG_DIR   string
+	RUNC_BINARY      string
+	INTEGRATION_ROOT string
+	STORAGE_OPTIONS  = "--storage-driver vfs"
+	ARTIFACT_DIR     = "/tmp/.artifacts"
+	IMAGES           = []string{"alpine", "busybox"}
+	ALPINE           = "docker.io/library/alpine:latest"
+	BB_GLIBC         = "docker.io/library/busybox:glibc"
+	fedoraMinimal    = "registry.fedoraproject.org/fedora-minimal:latest"
+)
+
+// PodmanSession wrapps the gexec.session so we can extend it
+type PodmanSession struct {
+	*gexec.Session
+}
+
+// PodmanTest struct for command line options
+type PodmanTest struct {
+	PodmanBinary        string
+	ConmonBinary        string
+	CrioRoot            string
+	CNIConfigDir        string
+	RunCBinary          string
+	RunRoot             string
+	StorageOptions      string
+	SignaturePolicyPath string
+	ArtifactPath        string
+	TempDir             string
+}
+
+// TestLibpod ginkgo master function
+func TestLibpod(t *testing.T) {
+	if reexec.Init() {
+		os.Exit(1)
+	}
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Libpod Suite")
+}
+
+var _ = BeforeSuite(func() {
+	//Cache images
+	cwd, _ := os.Getwd()
+	INTEGRATION_ROOT = filepath.Join(cwd, "../../")
+	podman := PodmanCreate("/tmp")
+	podman.ArtifactPath = ARTIFACT_DIR
+	if _, err := os.Stat(ARTIFACT_DIR); os.IsNotExist(err) {
+		if err = os.Mkdir(ARTIFACT_DIR, 0777); err != nil {
+			fmt.Printf("%q\n", err)
+			os.Exit(1)
+		}
+	}
+	for _, image := range IMAGES {
+		fmt.Printf("Caching %s...\n", image)
+		if err := podman.CreateArtifact(image); err != nil {
+			fmt.Printf("%q\n", err)
+			os.Exit(1)
+		}
+	}
+
+})
+
+// CreateTempDirin
+func CreateTempDirInTempDir() (string, error) {
+	return ioutil.TempDir("", "podman_test")
+}
+
+// PodmanCreate creates a PodmanTest instance for the tests
+func PodmanCreate(tempDir string) PodmanTest {
+	cwd, _ := os.Getwd()
+
+	podmanBinary := filepath.Join(cwd, "../../bin/podman")
+	if os.Getenv("PODMAN_BINARY") != "" {
+		podmanBinary = os.Getenv("PODMAN_BINARY")
+	}
+	conmonBinary := filepath.Join("/usr/libexec/crio/conmon")
+	if os.Getenv("CONMON_BINARY") != "" {
+		conmonBinary = os.Getenv("CONMON_BINARY")
+	}
+	storageOptions := STORAGE_OPTIONS
+	if os.Getenv("STORAGE_OPTIONS") != "" {
+		storageOptions = os.Getenv("STORAGE_OPTIONS")
+	}
+
+	runCBinary := "/usr/bin/runc"
+	CNIConfigDir := "/etc/cni/net.d"
+
+	return PodmanTest{
+		PodmanBinary:        podmanBinary,
+		ConmonBinary:        conmonBinary,
+		CrioRoot:            filepath.Join(tempDir, "crio"),
+		CNIConfigDir:        CNIConfigDir,
+		RunCBinary:          runCBinary,
+		RunRoot:             filepath.Join(tempDir, "crio-run"),
+		StorageOptions:      storageOptions,
+		SignaturePolicyPath: filepath.Join(INTEGRATION_ROOT, "test/policy.json"),
+		ArtifactPath:        ARTIFACT_DIR,
+		TempDir:             tempDir,
+	}
+}
+
+//MakeOptions assembles all the podman main options
+func (p *PodmanTest) MakeOptions() []string {
+	return strings.Split(fmt.Sprintf("--root %s --runroot %s --runtime %s --conmon %s --cni-config-dir %s",
+		p.CrioRoot, p.RunRoot, p.RunCBinary, p.ConmonBinary, p.CNIConfigDir), " ")
+}
+
+// Podman is the exec call to podman on the filesystem
+func (p *PodmanTest) Podman(args []string) *PodmanSession {
+	podmanOptions := p.MakeOptions()
+	podmanOptions = append(podmanOptions, strings.Split(p.StorageOptions, " ")...)
+	podmanOptions = append(podmanOptions, args...)
+	fmt.Printf("Running: %s %s\n", p.PodmanBinary, strings.Join(podmanOptions, " "))
+	command := exec.Command(p.PodmanBinary, podmanOptions...)
+	session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
+	if err != nil {
+		Fail(fmt.Sprintf("unable to run podman command: %s", strings.Join(podmanOptions, " ")))
+	}
+	return &PodmanSession{session}
+}
+
+// Cleanup cleans up the temporary store
+func (p *PodmanTest) Cleanup() {
+	// Remove all containers
+	session := p.Podman([]string{"rm", "-fa"})
+	session.Wait()
+	// Nuke tempdir
+	if err := os.RemoveAll(p.TempDir); err != nil {
+		fmt.Printf("%q\n", err)
+	}
+}
+
+// GrepString takes session output and behaves like grep. it returns a bool
+// if successful and an array of strings on positive matches
+func (s *PodmanSession) GrepString(term string) (bool, []string) {
+	var (
+		greps   []string
+		matches bool
+	)
+
+	for _, line := range strings.Split(s.OutputToString(), "\n") {
+		if strings.Contains(line, term) {
+			matches = true
+			greps = append(greps, line)
+		}
+	}
+	return matches, greps
+}
+
+// Pull Images pulls multiple images
+func (p *PodmanTest) PullImages(images []string) error {
+	for _, i := range images {
+		p.PullImage(i)
+	}
+	return nil
+}
+
+// Pull Image a single image
+// TODO should the timeout be configurable?
+func (p *PodmanTest) PullImage(image string) error {
+	session := p.Podman([]string{"pull", image})
+	session.Wait(60)
+	Expect(session.ExitCode()).To(Equal(0))
+	return nil
+}
+
+// OutputToString formats session output to string
+func (s *PodmanSession) OutputToString() string {
+	fields := strings.Fields(fmt.Sprintf("%s", s.Out.Contents()))
+	return strings.Join(fields, " ")
+}
+
+// SystemExec is used to exec a system command to check its exit code or output
+func (p *PodmanTest) SystemExec(command string, args []string) *PodmanSession {
+	c := exec.Command(command, args...)
+	session, err := gexec.Start(c, GinkgoWriter, GinkgoWriter)
+	if err != nil {
+		Fail(fmt.Sprintf("unable to run command: %s %s", command, strings.Join(args, " ")))
+	}
+	return &PodmanSession{session}
+}
+
+// CreateArtifact creates a cached image in the artifact dir
+func (p *PodmanTest) CreateArtifact(image string) error {
+	imageName := fmt.Sprintf("docker://%s", image)
+	systemContext := types.SystemContext{
+		SignaturePolicyPath: p.SignaturePolicyPath,
+	}
+	policy, err := signature.DefaultPolicy(&systemContext)
+	if err != nil {
+		return errors.Errorf("error loading signature policy: %v", err)
+	}
+	policyContext, err := signature.NewPolicyContext(policy)
+	if err != nil {
+		return errors.Errorf("error loading signature policy: %v", err)
+	}
+	defer func() {
+		_ = policyContext.Destroy()
+	}()
+	options := &copy.Options{}
+
+	importRef, err := alltransports.ParseImageName(imageName)
+	if err != nil {
+		return errors.Errorf("error parsing image name %v: %v", image, err)
+	}
+
+	exportTo := filepath.Join("dir:", p.ArtifactPath, image)
+	exportRef, err := alltransports.ParseImageName(exportTo)
+	if err != nil {
+		return errors.Errorf("error parsing image name %v: %v", exportTo, err)
+	}
+
+	return copy.Image(policyContext, exportRef, importRef, options)
+
+	return nil
+}
+
+// RestoreArtifact puts the cached image into our test store
+func (p *PodmanTest) RestoreArtifact(image string) error {
+	storeOptions := sstorage.DefaultStoreOptions
+	storeOptions.GraphDriverName = "vfs"
+	//storeOptions.GraphDriverOptions = storageOptions
+	storeOptions.GraphRoot = p.CrioRoot
+	storeOptions.RunRoot = p.RunRoot
+	store, err := sstorage.GetStore(storeOptions)
+
+	options := &copy.Options{}
+	if err != nil {
+		return errors.Errorf("error opening storage: %v", err)
+	}
+	defer func() {
+		_, _ = store.Shutdown(false)
+	}()
+
+	storage.Transport.SetStore(store)
+	ref, err := storage.Transport.ParseStoreReference(store, image)
+	if err != nil {
+		return errors.Errorf("error parsing image name: %v", err)
+	}
+
+	importFrom := fmt.Sprintf("dir:%s", filepath.Join(p.ArtifactPath, image))
+	importRef, err := alltransports.ParseImageName(importFrom)
+	if err != nil {
+		return errors.Errorf("error parsing image name %v: %v", image, err)
+	}
+	systemContext := types.SystemContext{
+		SignaturePolicyPath: p.SignaturePolicyPath,
+	}
+	policy, err := signature.DefaultPolicy(&systemContext)
+	if err != nil {
+		return errors.Errorf("error loading signature policy: %v", err)
+	}
+	policyContext, err := signature.NewPolicyContext(policy)
+	if err != nil {
+		return errors.Errorf("error loading signature policy: %v", err)
+	}
+	defer func() {
+		_ = policyContext.Destroy()
+	}()
+	err = copy.Image(policyContext, ref, importRef, options)
+	if err != nil {
+		return errors.Errorf("error importing %s: %v", importFrom, err)
+	}
+	return nil
+}
+
+// RestoreAllArtifacts unpacks all cached images
+func (p *PodmanTest) RestoreAllArtifacts() error {
+	for _, image := range IMAGES {
+		if err := p.RestoreArtifact(image); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/test/e2e/rmi_test.go b/test/e2e/rmi_test.go
new file mode 100644
index 000000000..895c812c6
--- /dev/null
+++ b/test/e2e/rmi_test.go
@@ -0,0 +1,70 @@
+package integration
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Podman rmi", func() {
+	var (
+		tempdir    string
+		err        error
+		podmanTest PodmanTest
+		image1     = "docker.io/library/alpine:latest"
+		image3     = "docker.io/library/busybox:glibc"
+	)
+
+	BeforeEach(func() {
+		tempdir, err = CreateTempDirInTempDir()
+		if err != nil {
+			os.Exit(1)
+		}
+		podmanTest = PodmanCreate(tempdir)
+		podmanTest.RestoreAllArtifacts()
+	})
+
+	AfterEach(func() {
+		podmanTest.Cleanup()
+
+	})
+
+	It("podman rmi bogus image", func() {
+		session := podmanTest.Podman([]string{"rmi", "debian:6.0.10"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(125))
+
+	})
+
+	It("podman rmi with fq name", func() {
+		session := podmanTest.Podman([]string{"rmi", image1})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman rmi with short name", func() {
+		session := podmanTest.Podman([]string{"rmi", "alpine"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman rmi all images", func() {
+		podmanTest.PullImages([]string{image3})
+		session := podmanTest.Podman([]string{"rmi", "-a"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman rmi all images forceably with short options", func() {
+		podmanTest.PullImages([]string{image3})
+		session := podmanTest.Podman([]string{"rmi", "-fa"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+})
diff --git a/test/e2e/run_test.go b/test/e2e/run_test.go
new file mode 100644
index 000000000..8f1aa0053
--- /dev/null
+++ b/test/e2e/run_test.go
@@ -0,0 +1,187 @@
+package integration
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Podman run", func() {
+	var (
+		tempdir    string
+		err        error
+		podmanTest PodmanTest
+	)
+
+	BeforeEach(func() {
+		tempdir, err = CreateTempDirInTempDir()
+		if err != nil {
+			os.Exit(1)
+		}
+		podmanTest = PodmanCreate(tempdir)
+		podmanTest.RestoreAllArtifacts()
+	})
+
+	AfterEach(func() {
+		podmanTest.Cleanup()
+	})
+
+	It("podman run a container based on local image", func() {
+		session := podmanTest.Podman([]string{"run", ALPINE, "ls"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman run a container based on local image with short options", func() {
+		session := podmanTest.Podman([]string{"run", "-dt", ALPINE, "ls"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman run a container based on remote image", func() {
+		session := podmanTest.Podman([]string{"run", "-dt", BB_GLIBC, "ls"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+
+	})
+
+	It("podman run selinux grep test", func() {
+		selinux := podmanTest.SystemExec("ls", []string{"/usr/sbin/selinuxenabled"})
+		if selinux.ExitCode() != 0 {
+			Skip("SELinux not enabled")
+		}
+		session := podmanTest.Podman([]string{"run", "-it", "--security-opt", "label=level:s0:c1,c2", ALPINE, "cat", "/proc/self/attr/current"})
+		session.Wait(30)
+		Expect(session.ExitCode()).To(Equal(0))
+		match, _ := session.GrepString("s0:c1,c2")
+		Expect(match).Should(BeTrue())
+	})
+
+	It("podman run capabilities test", func() {
+		session := podmanTest.Podman([]string{"run", "--rm", "--cap-add", "all", ALPINE, "cat", "/proc/self/status"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--cap-add", "sys_admin", ALPINE, "cat", "/proc/self/status"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--cap-drop", "all", ALPINE, "cat", "/proc/self/status"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--cap-drop", "setuid", ALPINE, "cat", "/proc/self/status"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+	})
+
+	It("podman run environment test", func() {
+		session := podmanTest.Podman([]string{"run", "--rm", "--env", "FOO=BAR", ALPINE, "printenv", "FOO"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		match, _ := session.GrepString("BAR")
+		Expect(match).Should(BeTrue())
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--env", "PATH=/bin", ALPINE, "printenv", "PATH"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		match, _ = session.GrepString("/bin")
+		Expect(match).Should(BeTrue())
+
+		os.Setenv("FOO", "BAR")
+		session = podmanTest.Podman([]string{"run", "--rm", "--env", "FOO", ALPINE, "printenv", "FOO"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		match, _ = session.GrepString("BAR")
+		Expect(match).Should(BeTrue())
+		os.Unsetenv("FOO")
+
+		session = podmanTest.Podman([]string{"run", "--rm", ALPINE, "printenv"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		// This currently does not work
+		// Re-enable when hostname is an env variable
+		//session = podmanTest.Podman([]string{"run", "--rm", ALPINE, "sh", "-c", "printenv"})
+		//session.Wait(10)
+		//Expect(session.ExitCode()).To(Equal(0))
+		//match, _ = session.GrepString("HOSTNAME")
+		//Expect(match).Should(BeTrue())
+	})
+
+	It("podman run limits test", func() {
+		session := podmanTest.Podman([]string{"run", "--rm", "--ulimit", "rtprio=99", "--cap-add=sys_nice", fedoraMinimal, "cat", "/proc/self/sched"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--ulimit", "nofile=2048:2048", fedoraMinimal, "ulimit", "-n"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("2048"))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--ulimit", "nofile=1024:1028", fedoraMinimal, "ulimit", "-n"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("1024"))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--oom-kill-disable=true", fedoraMinimal, "echo", "memory-hog"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+
+		session = podmanTest.Podman([]string{"run", "--rm", "--oom-score-adj=100", fedoraMinimal, "cat", "/proc/self/oom_score_adj"})
+		session.Wait(45)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("100"))
+	})
+
+	It("podman run with volume flag", func() {
+		Skip("Skip until we diagnose the regression of volume mounts")
+		mountPath := filepath.Join(podmanTest.TempDir, "secrets")
+		os.Mkdir(mountPath, 0755)
+		session := podmanTest.Podman([]string{"run", "--rm", "-v", fmt.Sprintf("%s:/run/test", mountPath), ALPINE, "cat", "/proc/self/mountinfo"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("/run/test rw,relatime"))
+
+		mountPath = filepath.Join(podmanTest.TempDir, "secrets")
+		os.Mkdir(mountPath, 0755)
+		session = podmanTest.Podman([]string{"run", "--rm", "-v", fmt.Sprintf("%s:/run/test:ro", mountPath), ALPINE, "cat", "/proc/self/mountinfo"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("/run/test ro,relatime"))
+
+		mountPath = filepath.Join(podmanTest.TempDir, "secrets")
+		os.Mkdir(mountPath, 0755)
+		session = podmanTest.Podman([]string{"run", "--rm", "-v", fmt.Sprintf("%s:/run/test:shared", mountPath), ALPINE, "cat", "/proc/self/mountinfo"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("/run/test rw,relatime, shared"))
+	})
+
+	It("podman run with cidfile", func() {
+		session := podmanTest.Podman([]string{"run", "--cidfile", "/tmp/cidfile", ALPINE, "ls"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		err := os.Remove("/tmp/cidfile")
+		Expect(err).To(BeNil())
+	})
+
+	It("podman run sysctl test", func() {
+		session := podmanTest.Podman([]string{"run", "--rm", "--sysctl", "net.core.somaxconn=65535", ALPINE, "sysctl", "net.core.somaxconn"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("net.core.somaxconn = 65535"))
+	})
+
+	It("podman run blkio-weight test", func() {
+		session := podmanTest.Podman([]string{"run", "--rm", "--blkio-weight=15", ALPINE, "cat", "/sys/fs/cgroup/blkio/blkio.weight"})
+		session.Wait(10)
+		Expect(session.ExitCode()).To(Equal(0))
+		Expect(session.OutputToString()).To(ContainSubstring("15"))
+	})
+})
diff --git a/test/e2e/wait_test.go b/test/e2e/wait_test.go
new file mode 100644
index 000000000..5448b5ae4
--- /dev/null
+++ b/test/e2e/wait_test.go
@@ -0,0 +1,63 @@
+package integration
+
+import (
+	"os"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Podman wait", func() {
+	var (
+		tempdir    string
+		err        error
+		podmanTest PodmanTest
+	)
+
+	BeforeEach(func() {
+		tempdir, err = CreateTempDirInTempDir()
+		if err != nil {
+			os.Exit(1)
+		}
+		podmanTest = PodmanCreate(tempdir)
+		podmanTest.RestoreAllArtifacts()
+	})
+
+	AfterEach(func() {
+		podmanTest.Cleanup()
+
+	})
+
+	It("podman wait on bogus container", func() {
+		session := podmanTest.Podman([]string{"wait", "1234"})
+		session.Wait()
+		Expect(session.ExitCode()).To(Equal(125))
+
+	})
+
+	It("podman wait on a stopped container", func() {
+		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "ls"})
+		session.Wait(10)
+		cid := session.OutputToString()
+		Expect(session.ExitCode()).To(Equal(0))
+		session = podmanTest.Podman([]string{"wait", cid})
+		session.Wait()
+	})
+
+	It("podman wait on a sleeping container", func() {
+		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "10"})
+		session.Wait(20)
+		cid := session.OutputToString()
+		Expect(session.ExitCode()).To(Equal(0))
+		session = podmanTest.Podman([]string{"wait", cid})
+		session.Wait(20)
+	})
+
+	It("podman wait on latest container", func() {
+		session := podmanTest.Podman([]string{"run", "-d", ALPINE, "sleep", "10"})
+		session.Wait(20)
+		Expect(session.ExitCode()).To(Equal(0))
+		session = podmanTest.Podman([]string{"wait", "-l"})
+		session.Wait(20)
+	})
+})