path: root/test/system/001-basic.bats

#!/usr/bin/env bats
#
# Simplest set of podman tests. If any of these fail, we have serious problems.
#

load helpers

# Override standard setup! We don't yet trust podman-images or podman-rm
function setup() {
    :
}

#### DO NOT ADD ANY TESTS HERE! ADD NEW TESTS AT BOTTOM!

@test "podman version emits reasonable output" {
    run_podman version

    # First line of podman version is "Client: *Podman Engine".
    # Just delete it (i.e. remove the first entry from the 'lines' array)
    if expr "${lines[0]}" : "Client: *" >/dev/null; then
        lines=("${lines[@]:1}")
    fi

    is "${lines[0]}" "Version:[ ]\+[1-9][0-9.]\+" "Version line 1"
    is "$output" ".*Go Version: \+"               "'Go Version' in output"
    is "$output" ".*API Version: \+"		  "API version in output"

    # Test that build date is reasonable, e.g. after 2019-01-01
    local built=$(expr "$output" : ".*Built: \+\(.*\)" | head -n1)
    local built_t=$(date --date="$built" +%s)
    assert "$built_t" -gt 1546300800 "Preposterous 'Built' time in podman version"

    run_podman -v
    is "$output" "podman.*version \+"               "'Version line' in output"

    run_podman --config foobar version
    is "$output" ".*The --config flag is ignored by Podman. Exists for Docker compatibility\+"		  "verify warning for --config option"
}

@test "podman info" {
    # These will be displayed on the test output stream, offering an
    # at-a-glance overview of important system configuration details
    local -a want=(
        'Arch:{{.Host.Arch}}'
        'OS:{{.Host.Distribution.Distribution}}{{.Host.Distribution.Version}}'
        'Runtime:{{.Host.OCIRuntime.Name}}'
        'Rootless:{{.Host.Security.Rootless}}'
        'Events:{{.Host.EventLogger}}'
        'Logdriver:{{.Host.LogDriver}}'
        'Cgroups:{{.Host.CgroupsVersion}}+{{.Host.CgroupManager}}'
        'Net:{{.Host.NetworkBackend}}'
    )
    run_podman info --format "$(IFS='/' echo ${want[@]})"
    echo "# $output" >&3
}


@test "podman --context emits reasonable output" {
    if ! is_remote; then
        skip "only applicable on podman-remote"
    fi
    # All we care about here is that the command passes
    run_podman --context=default version

    # This one must fail
    run_podman 125 --context=swarm version
    is "$output" \
       "Error: failed to resolve active destination: \"swarm\" service destination not found" \
       "--context=swarm should fail"
}

@test "podman can pull an image" {
    run_podman rmi -a
    run_podman pull $IMAGE

    # Regression test for https://github.com/containers/image/pull/1615
    # Make sure no progress lines are duplicated
    local -A line_seen
    for line in "${lines[@]}"; do
        if [[ -n "${line_seen[$line]}" ]]; then
            die "duplicate podman-pull output line: $line"
        fi
        line_seen[$line]=1
    done

    # Also make sure that the tag@digest syntax is supported.
    run_podman inspect --format "{{ .Digest }}" $IMAGE
    digest=$output
    run_podman pull $IMAGE@$digest

    # Now untag the digest reference again.
    run_podman untag $IMAGE $IMAGE@$digest

    # Make sure the original image is still present (#11557).
    run_podman image exists $IMAGE
}

# PR #7212: allow --remote anywhere before subcommand, not just as 1st flag
@test "podman-remote : really is remote, works as --remote option" {
    if ! is_remote; then
        skip "only applicable on podman-remote"
    fi

    # First things first: make sure our podman-remote actually is remote!
    run_podman version
    is "$output" ".*Server:" "the given podman path really contacts a server"

    # $PODMAN may be a space-separated string, e.g. if we include a --url.
    # Split it into its components; remove "-remote" from the command path;
    # and preserve any other args if present.
    local -a podman_as_array=($PODMAN)
    local    podman_path=${podman_as_array[0]}
    local    podman_non_remote=${podman_path%%-remote}
    local -a podman_args=("${podman_as_array[@]:1}")

    # This always worked: running "podman --remote ..."
    PODMAN="${podman_non_remote} --remote ${podman_args[@]}" run_podman version
    is "$output" ".*Server:" "podman --remote: contacts server"

    # This was failing: "podman --foo --bar --remote".
    PODMAN="${podman_non_remote} --log-level=error ${podman_args[@]} --remote" run_podman version
    is "$output" ".*Server:" "podman [flags] --remote: contacts server"

    # ...but no matter what, --remote is never allowed after subcommand
    PODMAN="${podman_non_remote} ${podman_args[@]}" run_podman 125 version --remote
    is "$output" "Error: unknown flag: --remote
See 'podman version --help'" "podman version --remote"
}

@test "podman-remote: defaults" {
    skip_if_remote "only applicable on a local run"

    # By default, podman should include '--remote' in its help output
    run_podman --help
    assert "$output" =~ " --remote " "podman --help includes the --remote option"

    # When it detects CONTAINER_HOST or _CONNECTION, --remote is not an option
    CONTAINER_HOST=foobar run_podman --help
    assert "$output" !~ " --remote " \
           "podman --help, with CONTAINER_HOST set, should not show --remote"

    CONTAINER_CONNECTION=foobar run_podman --help
    assert "$output" !~ " --remote " \
           "podman --help, with CONTAINER_CONNECTION set, should not show --remote"

    # When it detects --url or --connection, --remote is not an option
    run_podman --url foobar --help
    assert "$output" !~ " --remote " \
           "podman --help, with --url set, should not show --remote"

    run_podman --connection foobar --help
    assert "$output" !~ " --remote " \
           "podman --help, with --connection set, should not show --remote"
}

# Check that just calling "podman-remote" prints the usage message even
# without a running endpoint. Use "podman --remote" for this as this works the same.
@test "podman-remote: check for command usage message without a running endpoint" {
    if is_remote; then
        skip "only applicable on a local run since this requires no endpoint"
    fi

    run_podman 125 --remote
    is "$output" ".*Usage:" "podman --remote show usage message without running endpoint"
}

# This is for development only; it's intended to make sure our timeout
# in run_podman continues to work. This test should never run in production
# because it will, by definition, fail.
@test "timeout" {
    if [ -z "$PODMAN_RUN_TIMEOUT_TEST" ]; then
        skip "define \$PODMAN_RUN_TIMEOUT_TEST to enable this test"
    fi
    PODMAN_TIMEOUT=10 run_podman run $IMAGE sleep 90
    echo "*** SHOULD NEVER GET HERE"
}


# Too many tests rely on jq for parsing JSON.
#
# If absolutely necessary, one could establish a convention such as
# defining PODMAN_TEST_SKIP_JQ=1 and adding a skip_if_no_jq() helper.
# For now, let's assume this is not absolutely necessary.
@test "jq is installed and produces reasonable output" {
    type -path jq >/dev/null || die "FATAL: 'jq' tool not found."

    run jq -r .a.b < <(echo '{ "a": { "b" : "you found me" } }')
    is "$output" "you found me" "sample invocation of 'jq'"
}

@test "podman --log-level recognizes log levels" {
    run_podman 1 --log-level=telepathic info
    is "$output" 'Log Level "telepathic" is not supported.*'

    run_podman --log-level=trace   info
    if ! is_remote; then
        # podman-remote does not do any trace logging
        assert "$output" =~ " level=trace " "log-level=trace"
    fi
    assert "$output" =~ " level=debug " "log-level=trace includes debug"
    assert "$output" =~ " level=info "  "log-level=trace includes info"
    assert "$output" !~ " level=warn"   "log-level=trace does not show warn"

    run_podman --log-level=debug   info
    assert "$output" !~ " level=trace " "log-level=debug does not show trace"
    assert "$output" =~ " level=debug " "log-level=debug"
    assert "$output" =~ " level=info "  "log-level=debug includes info"
    assert "$output" !~ " level=warn"   "log-level=debug does not show warn"

    run_podman --log-level=info    info
    assert "$output" !~ " level=trace " "log-level=info does not show trace"
    assert "$output" !~ " level=debug " "log-level=info does not show debug"
    assert "$output" =~ " level=info "  "log-level=info"

    run_podman --log-level=warn    info
    assert "$output" !~ " level=" "log-level=warn shows no logs at all"

    # Force a warning (local podman only; podman-remote doesn't check versions)
    if ! is_remote; then
        run_podman --log-level=warn --storage-opt=mount_program=/bin/false info
        assert "$output" =~ " level=warning msg=\"Failed to retrieve " \
               "log-level=warn"

        # confirm that default level is "warn", by invoking without --log-level
        run_podman --storage-opt=mount_program=/bin/false info
        assert "$output" =~ " level=warning msg=\"Failed to retrieve " \
               "default log level includes warning messages"
    fi

    run_podman --log-level=warning info
    assert "$output" !~ " level=" "log-level=warning shows no logs at all"

    run_podman --log-level=error   info
    assert "$output" !~ " level=" "log-level=error shows no logs at all"

    # error, fatal, panic:
    if is_remote; then
        # podman-remote does not grok --runtime; all we can do is test parsing
        for level in error fatal panic; do
            run_podman --log-level=$level info
            assert "$output" !~ " level=" \
                   "log-level=$level shows no logs at all"
        done
    else
        # local podman only
        run_podman --log-level=error --storage-opt=mount_program=/bin/false --runtime=/bin/false info
        assert "$output" =~ " level=error msg=\"Getting info on OCI runtime " \
               "log-level=error shows "
        assert "$output" !~ " level=warn" \
               "log-level=error does not show warnings"

        run_podman --log-level=fatal --storage-opt=mount_program=/bin/false --runtime=/bin/false info
        assert "$output" !~ " level=" "log-level=fatal shows no logs at all"

        run_podman --log-level=panic --storage-opt=mount_program=/bin/false --runtime=/bin/false info
        assert "$output" !~ " level=" "log-level=panic shows no logs at all"
    fi

    # docker compat
    run_podman --debug   info
    assert "$output" =~ " level=debug " "podman --debug gives debug output"
    run_podman -D        info
    assert "$output" =~ " level=debug " "podman -D gives debug output"

    run_podman 1 --debug --log-level=panic info
    is "$output" "Setting --log-level and --debug is not allowed"
}

# vim: filetype=sh