$ pip install paramiko
$ py.test -v --hosts=localhost,root@webserver:2222 test_myinfra.py
====================== test session starts ======================
platform linux -- Python 2.7.3 -- py-1.4.26 -- pytest-2.6.4
plugins: testinfra
collected 3 items
test_myinfra.py::test_passwd_file[localhost] PASSED
test_myinfra.py::test_nginx_is_installed[localhost] PASSED
test_myinfra.py::test_nginx_running_and_enabled[localhost] PASSED
test_myinfra.py::test_passwd_file[root@webserver:2222] PASSED
test_myinfra.py::test_nginx_is_installed[root@webserver:2222] PASSED
test_myinfra.py::test_nginx_running_and_enabled[root@webserver:2222] PASSED
=================== 6 passed in 8.49 seconds ====================

testinfra_hosts = ["localhost", "root@webserver:2222"]
def test_foo(host):
    [....]

$ pip install pytest-xdist
# Launch tests using 3 processes
$ py.test -n 3 -v --host=web1,web2,web3,web4,web5,web6 test_myinfra.py

# Test recursively all test files (starting with `test_`) in current directory
$ py.test
# Filter function/hosts with pytest -k option
$ py.test --hosts=webserver,dnsserver -k webserver -k nginx

$ pip install pytest-testinfra[ansible,salt]

$ py.test --sudo test_myinfra.py

$ py.test --ssh-config=/path/to/ssh_config --hosts=server

$ py.test --hosts='docker://[user@]container_id_or_name'

$ py.test --hosts='podman://[user@]container_id_or_name'

$ py.test --hosts='ssh://server'
$ py.test --ssh-config=/path/to/ssh_config --hosts='ssh://server'
$ py.test --ssh-identity-file=/path/to/key --hosts='ssh://server'
$ py.test --hosts='ssh://server?timeout=60&controlpersist=120'
$ py.test --hosts='ssh://server' --ssh-extra-args='-o StrictHostKeyChecking=no'

$ py.test --hosts='salt://*'
$ py.test --hosts='salt://minion1,salt://minion2'
$ py.test --hosts='salt://web*'
$ py.test --hosts='salt://G@os:Debian'

$ py.test --hosts='ansible://all' # tests all inventory hosts
$ py.test --hosts='ansible://host1,ansible://host2'
$ py.test --hosts='ansible://web*'

$ py.test --force-ansible --hosts='ansible://all'
$ py.test --hosts='ansible://host?force_ansible=True'

# will use the default namespace and default container
$ py.test --hosts='kubectl://mypod-a1b2c3'
# specify container name and namespace
$ py.test --hosts='kubectl://somepod-2536ab?container=nginx&namespace=web'
# specify the kubeconfig context to use
$ py.test --hosts='kubectl://somepod-2536ab?context=k8s-cluster-a&container=nginx'
# you can specify kubeconfig either from KUBECONFIG environment variable
# or when working with multiple configuration with the "kubeconfig" option
$ py.test --hosts='kubectl://somepod-123?kubeconfig=/path/kubeconfig,kubectl://otherpod-123?kubeconfig=/other/kubeconfig'

# will use the default namespace and default container
$ py.test --hosts='openshift://mypod-a1b2c3'
# specify container name and namespace
$ py.test --hosts='openshift://somepod-2536ab?container=nginx&namespace=web'
# you can specify kubeconfig either from KUBECONFIG environment variable
# or when working with multiple configuration with the "kubeconfig" option
$ py.test --hosts='openshift://somepod-123?kubeconfig=/path/kubeconfig,openshift://otherpod-123?kubeconfig=/other/kubeconfig'

$ py.test --hosts='winrm://Administrator:Password@127.0.0.1'
$ py.test --hosts='winrm://vagrant@127.0.0.1:2200?no_ssl=true&no_verify_ssl=true'

$ py.test --hosts='winrm://vagrant@127.0.0.1:2200?read_timeout_sec=120&operation_timeout_sec=100'

$ py.test --hosts='lxc://container_name'

def test_foo(host):
    # [...]

property has_command_v: bool

Return True if command -v is available

exists(command: str) -> bool

Return True if given command exist in $PATH

find_command(command: str, extrapaths: Iterable[str] = ('/sbin', '/usr/sbin')) -> str

Return path of given command

raise ValueError if command cannot be found

run(command: str, *args: str, **kwargs: Any) -> CommandResult

Run given command and return rc (exit status), stdout and stderr

>>> cmd = host.run("ls -l /etc/passwd")
>>> cmd.rc
0
>>> cmd.stdout
'-rw-r--r-- 1 root root 1790 Feb 11 00:28 /etc/passwd\n'
>>> cmd.stderr
''
>>> cmd.succeeded
True
>>> cmd.failed
False

Good practice: always use shell arguments quoting to avoid shell injection

>>> cmd = host.run("ls -l -- %s", "/;echo inject")
CommandResult(
    rc=2, stdout='',
    stderr=(
      'ls: cannot access /;echo inject: No such file or directory\n'),
    command="ls -l '/;echo inject'")

run_expect(expected: list[int], command: str, *args: str, **kwargs: Any) -> CommandResult

Run command and check it return an expected exit status

run_test(command: str, *args: str, **kwargs: Any) -> CommandResult

Run command and check it return an exit status of 0 or 1

check_output(command: str, *args: str, **kwargs: Any) -> str

Get stdout of a command which has run successfully

classmethod get_host(hostspec: str, **kwargs: Any) -> Host

Return a Host instance from hostspec

hostspec should be like <backend_type>://<name>?param1=value1&param2=value2

Params can also be passed in **kwargs (eg. get_host("local://", sudo=True) is equivalent to get_host("local://?sudo=true"))

Examples:

>>> get_host("local://", sudo=True)
>>> get_host("paramiko://user@host", ssh_config="/path/my_ssh_config")
>>> get_host("ansible://all?ansible_inventory=/etc/ansible/inventory")

exception AnsibleException(result)

Exception raised when an error occur in an ansible call

result from ansible can be accessed through the result attribute

>>> try:
...     host.ansible("command", "echo foo")
... except host.ansible.AnsibleException as exc:
...     assert exc.result['failed'] is True
...     assert exc.result['msg'] == 'Skipped. You might want to try check=False'  # noqa

get_variables()

Returns a dict of ansible variables

>>> host.ansible.get_variables()
{
    'inventory_hostname': 'localhost',
    'group_names': ['ungrouped'],
    'foo': 'bar',
}

property name

Return host name

property namespace

Return network namespace

property namespace_exists

Test if the network namespace exists

property is_resolvable

Return if address is resolvable

property is_reachable

Return if address is reachable

property ip_addresses

Return IP addresses of host

property ipv4_addresses

Return IPv4 addresses of host

property ipv6_addresses

Return IPv6 addresses of host

port(port)

Return address-port pair

property is_partition

Return True if the device is a partition.

>>> host.block_device("/dev/sda1").is_partition
True

>>> host.block_device("/dev/sda").is_partition
False

property size

Return size if the device in bytes.

>>> host.block_device("/dev/sda1").size
512110190592

property sector_size

Return sector size for the device in bytes.

>>> host.block_device("/dev/sda1").sector_size
512

property block_size

Return block size for the device in bytes.

>>> host.block_device("/dev/sda").block_size
4096

property start_sector

Return start sector of the device on the underlying device.

>>> host.block_device("/dev/sda1").start_sector
2048

>>> host.block_device("/dev/md0").start_sector
0

property is_writable

Return True if device is writable (have no RO status)

>>> host.block_device("/dev/sda").is_writable
True

>>> host.block_device("/dev/loop1").is_writable
False

property ra

Return Read Ahead for the device in 512-bytes sectors.

>>> host.block_device("/dev/sda").ra
256

classmethod client_version()

Docker client version

classmethod server_version()

Docker server version

classmethod version(format=None)

Docker version with an optional format (Go template).

>>> host.docker.version()
Client: Docker Engine - Community
...
>>> host.docker.version("{{.Client.Context}}"))
default

classmethod get_containers(**filters)

Return a list of containers

By default return list of all containers, including non-running containers.

Filtering can be done using filters keys defined on https://docs.docker.com/engine/reference/commandline/ps/#filtering

Multiple filters for a given key is handled by giving a list of string as value.

>>> host.docker.get_containers()
[<docker nginx>, <docker redis>, <docker app>]
# Get all running containers
>>> host.docker.get_containers(status="running")
[<docker app>]
# Get containers named "nginx"
>>> host.docker.get_containers(name="nginx")
[<docker nginx>]
# Get containers named "nginx" or "redis"
>>> host.docker.get_containers(name=["nginx", "redis"])
[<docker nginx>, <docker redis>]

property exists

Test if file exists

>>> host.file("/etc/passwd").exists
True
>>> host.file("/nonexistent").exists
False

property is_file

Test if the path is a regular file

property is_directory

Test if the path exists and a directory

property is_executable

Test if the path exists and permission to execute is granted

property is_pipe

Test if the path exists and is a pipe

property is_socket

Test if the path exists and is a socket

property is_symlink

Test if the path exists and is a symbolic link

property linked_to

Resolve symlink

>>> host.file("/var/lock").linked_to
'/run/lock'

property user

Return file owner as string

>>> host.file("/etc/passwd").user
'root'

property uid

Return file user id as integer

>>> host.file("/etc/passwd").uid
0

property group

Return file group name as string

property gid

Return file group id as integer

property mode

Return file mode as octal integer

>>> host.file("/etc/shadow").mode
416  # Oo640 octal
>>> host.file("/etc/shadow").mode == 0o640
True
>>> oct(host.file("/etc/shadow").mode) == '0o640'
True

You can also utilize the file mode constants from the stat library for testing file mode.

>>> import stat
>>> host.file("/etc/shadow").mode == stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP
True

contains(pattern)

Checks content of file for pattern

This uses grep and thus follows the grep regex syntax.

property md5sum

Compute the MD5 message digest of the file content

property sha256sum

Compute the SHA256 message digest of the file content

property content

Return file content as bytes

>>> host.file("/tmp/foo").content
b'caf\xc3\xa9'

property content_string

Return file content as string

>>> host.file("/tmp/foo").content_string
'café'

property mtime

Return time of last modification as datetime.datetime object

>>> host.file("/etc/passwd").mtime
datetime.datetime(2015, 3, 15, 20, 25, 40)

property size

Return size of file in bytes

listdir()

Return list of items under the directory

>>> host.file("/tmp").listdir()
['foo_file', 'bar_dir']

property exists

Test if group exists

>>> host.group("wheel").exists
True
>>> host.group("nosuchgroup").exists
False

property gid

property members

Return all users that are members of this group.

property exists

property speed

property addresses

Return ipv4 and ipv6 addresses on the interface

>>> host.interface("eth0").addresses
['192.168.31.254', '192.168.31.252', 'fe80::e291:f5ff:fe98:6b8c']

property link

Return the link properties associated with the interface.

>>> host.interface("lo").link
{'address': '00:00:00:00:00:00',
'broadcast': '00:00:00:00:00:00',
'flags': ['LOOPBACK', 'UP', 'LOWER_UP'],
'group': 'default',
'ifindex': 1,
'ifname': 'lo',
'link_type': 'loopback',
'linkmode': 'DEFAULT',
'mtu': 65536,
'operstate': 'UNKNOWN',
'qdisc': 'noqueue',
'txqlen': 1000}

routes(scope=None)

Return the routes associated with the interface, optionally filtered by scope ("host", "link" or "global").

>>> host.interface("eth0").routes()
[{'dst': 'default',
'flags': [],
'gateway': '192.0.2.1',
'metric': 3003,
'prefsrc': '192.0.2.5',
'protocol': 'dhcp'},
{'dst': '192.0.2.0/24',
'flags': [],
'metric': 3003,
'prefsrc': '192.0.2.5',
'protocol': 'dhcp',
'scope': 'link'}]

classmethod names()

Return the names of all the interfaces.

>>> host.interface.names()
['lo', 'tunl0', 'ip6tnl0', 'eth0']

classmethod default(family=None)

Return the interface used for the default route.

>>> host.interface.default()
<interface eth0>

Optionally, the protocol family to use can be enforced.

>>> host.interface.default("inet6")
None

rules(table='filter', chain=None, version=4)

Returns list of iptables rules

>>> host.iptables.rules()
[
    '-P INPUT ACCEPT',
    '-P FORWARD ACCEPT',
    '-P OUTPUT ACCEPT',
    '-A INPUT -i lo -j ACCEPT',
    '-A INPUT -j REJECT'
    '-A FORWARD -j REJECT'
]
>>> host.iptables.rules("nat", "INPUT")
['-P PREROUTING ACCEPT']

property exists

Return True if the mountpoint exists

>>> host.mount_point("/").exists
True

>>> host.mount_point("/not/a/mountpoint").exists
False

property filesystem

Returns the filesystem type associated

>>> host.mount_point("/").filesystem
'ext4'

property device

Return the device associated

>>> host.mount_point("/").device
'/dev/sda1'

property options

Return a list of options that a mount point has been created with

>>> host.mount_point("/").options
['rw', 'relatime', 'data=ordered']

classmethod get_mountpoints()

Returns a list of MountPoint instances

>>> host.mount_point.get_mountpoints()
[<MountPoint(path=/proc, device=proc, filesystem=proc, options=rw,nosuid,nodev,noexec,relatime)>,
 <MountPoint(path=/, device=/dev/sda1, filesystem=ext4, options=rw,relatime,errors=remount-ro,data=ordered)>]

property is_installed

Test if the package is installed

>>> host.package("nginx").is_installed
True

Supported package systems:

property release

Return the release specific info from the package version

>>> host.package("nginx").release
'1.el6'

property version

Return package version as returned by the package system

>>> host.package("nginx").version
'1.2.1-2.2+wheezy3'

property is_installed

Test if the package is installed

>>> host.package("pip").is_installed
True

property version

Return package version as returned by pip

>>> host.package("pip").version
'18.1'

classmethod check(pip_path='pip')

Verify installed packages have compatible dependencies.

>>> cmd = host.pip.check()
>>> cmd.rc
0
>>> cmd.stdout
No broken requirements found.

Can only be used if pip check command is available, for pip versions >= 9.0.0.

classmethod get_packages(pip_path='pip')

Get all installed packages and versions returned by pip list:

>>> host.pip.get_packages(pip_path='~/venv/website/bin/pip')
{'Django': {'version': '1.10.2'},
 'mywebsite': {'version': '1.0a3', 'path': '/srv/website'},
 'psycopg2': {'version': '2.6.2'}}

classmethod get_outdated_packages(pip_path='pip')

Get all outdated packages with current and latest version

>>> host.pip.get_outdated_packages(
...     pip_path='~/venv/website/bin/pip')
{'Django': {'current': '1.10.2', 'latest': '1.10.3'}}

classmethod get_containers(**filters)

Return a list of containers

By default return list of all containers, including non-running containers.

Filtering can be done using filters keys defined in podman-ps(1).

Multiple filters for a given key is handled by giving a list of string as value.

>>> host.podman.get_containers()
[<podman nginx>, <podman redis>, <podman app>]
# Get all running containers
>>> host.podman.get_containers(status="running")
[<podman app>]
# Get containers named "nginx"
>>> host.podman.get_containers(name="nginx")
[<podman nginx>]
# Get containers named "nginx" or "redis"
>>> host.podman.get_containers(name=["nginx", "redis"])
[<podman nginx>, <podman redis>]

filter(**filters)

Get a list of matching process

>>> host.process.filter(user="root", comm="zsh")
[<process zsh (pid=2715)>, <process zsh (pid=10502)>, ...]

get(**filters)

Get one matching process

Raise RuntimeError if no process found or multiple process matching filters.

• Linux: detect Systemd, Upstart or OpenRC, fallback to SysV
• FreeBSD: service(1)
• OpenBSD: /etc/rc.d/$name check for is_running rcctl ls on for is_enabled (only OpenBSD >= 5.8)
• NetBSD: /etc/rc.d/$name onestatus for is_running (is_enabled is not yet implemented)

property exists

Test if service is exists

property is_running

Test if service is running

property is_enabled

Test if service is enabled

property is_valid

Test if service is valid

This method is only available in the systemd implementation, it will raise NotImplementedError in others implementation

property is_masked

Test if service is masked

This method is only available in the systemd implementation, it will raise NotImplementedError in others implementations

property systemd_properties

Properties of the service (unit).

Return service properties as a dict, empty properties are not returned.

>>> ntp = host.service("ntp")
>>> ntp.systemd_properties["FragmentPath"]
'/lib/systemd/system/ntp.service'

This method is only available in the systemd implementation, it will raise NotImplementedError in others implementations

Note: based on systemctl show

property is_listening

Test if socket is listening

>>> host.socket("unix:///var/run/docker.sock").is_listening
False
>>> # This HTTP server listen on all ipv4 addresses but not on ipv6
>>> host.socket("tcp://0.0.0.0:80").is_listening
True
>>> host.socket("tcp://:::80").is_listening
False
>>> host.socket("tcp://80").is_listening
False

NOTE:

property clients: List[Tuple[str, int] | None]

Return a list of clients connected to a listening socket

For tcp and udp sockets a list of pair (address, port) is returned. For unix sockets a list of None is returned (thus you can make a len() for counting clients).

>>> host.socket("tcp://22").clients
[('2001:db8:0:1', 44298), ('192.168.31.254', 34866)]
>>> host.socket("unix:///var/run/docker.sock")
[None, None, None]

classmethod get_listening_sockets()

Return a list of all listening sockets

>>> host.socket.get_listening_sockets()
['tcp://0.0.0.0:22', 'tcp://:::22', 'unix:///run/systemd/private', ...]

property is_running

Return True if managed service is in status RUNNING

property status

Return the status of the managed service

Status can be STOPPED, STARTING, RUNNING, BACKOFF, STOPPING, EXITED, FATAL, UNKNOWN.

See http://supervisord.org/subprocess.html#process-states

property pid

Return the pid (as int) of the managed service

classmethod get_services(supervisorctl_path='supervisorctl', supervisorctl_conf=None)

Get a list of services running under supervisor

>>> host.supervisor.get_services()
[<Supervisor(name="gunicorn", status="RUNNING", pid=4232)>
 <Supervisor(name="celery", status="FATAL", pid=None)>]

The path where supervisorctl and its configuration file reside can be specified.

>>> host.supervisor.get_services("/usr/bin/supervisorctl", "/etc/supervisor/supervisord.conf")
[<Supervisor(name="gunicorn", status="RUNNING", pid=4232)>
 <Supervisor(name="celery", status="FATAL", pid=None)>]

property type

OS type

>>> host.system_info.type
'linux'

property distribution

Distribution name

>>> host.system_info.distribution
'debian'

property release

Distribution release number

>>> host.system_info.release
'10.2'

property codename

Release code name

>>> host.system_info.codename
'bullseye'

property arch

Host architecture

>>> host.system_info.arch
'x86_64'

property name

Return user name

property exists

Test if user exists

>>> host.user("root").exists
True
>>> host.user("nosuchuser").exists
False

property uid

Return user ID

property gid

Return effective group ID

property group

Return effective group name

property gids

Return the list of user group IDs

property groups

Return the list of user group names

property home

Return the user home directory

property shell

Return the user login shell

property password

Return the encrypted user password

property password_max_days

Return the maximum number of days between password changes

property password_min_days

Return the minimum number of days between password changes

property gecos

Return the user comment/gecos field

property expiration_date

Return the account expiration date

>>> host.user("phil").expiration_date
datetime.datetime(2020, 1, 1, 0, 0)
>>> host.user("root").expiration_date
None

property succeeded: bool

Returns whether the command was successful

>>> host.run("true").succeeded
True

property failed: bool

Returns whether the command failed

>>> host.run("false").failed
True

property rc: int

Gets the returncode of a command

>>> host.run("true").rc
0

property stdout: str

Gets standard output (stdout) stream of an executed command

>>> host.run("mkdir -v new_directory").stdout
mkdir: created directory 'new_directory'

property stderr: str

Gets standard error (stderr) stream of an executed command

>>> host.run("mkdir new_directory").stderr
mkdir: cannot create directory 'new_directory': File exists

property stdout_bytes: bytes

Gets standard output (stdout) stream of an executed command as bytes

>>> host.run("mkdir -v new_directory").stdout_bytes
b"mkdir: created directory 'new_directory'"

property stderr_bytes: bytes

Gets standard error (stderr) stream of an executed command as bytes

>>> host.run("mkdir new_directory").stderr_bytes
b"mkdir: cannot create directory 'new_directory': File exists"

>>> import testinfra
>>> host = testinfra.get_host("paramiko://root@server:2222", sudo=True)
>>> host.file("/etc/shadow").mode == 0o640
True

import testinfra
def test_same_passwd():
    a = testinfra.get_host("ssh://a")
    b = testinfra.get_host("ssh://b")
    assert a.file("/etc/passwd").content == b.file("/etc/passwd").content

# BAD: If the test fails on nginx, python is not tested
def test_packages(host):
    for name, version in (
        ("nginx", "1.6"),
        ("python", "2.7"),
    ):
        pkg = host.package(name)
        assert pkg.is_installed
        assert pkg.version.startswith(version)
# GOOD: Each package is tested
# $ py.test -v test.py
# [...]
# test.py::test_package[local-nginx-1.6] PASSED
# test.py::test_package[local-python-2.7] PASSED
# [...]
import pytest
@pytest.mark.parametrize("name,version", [
    ("nginx", "1.6"),
    ("python", "2.7"),
])
def test_packages(host, name, version):
    pkg = host.package(name)
    assert pkg.is_installed
    assert pkg.version.startswith(version)

import unittest
import testinfra
class Test(unittest.TestCase):
    def setUp(self):
        self.host = testinfra.get_host("paramiko://root@host")
    def test_nginx_config(self):
        self.assertEqual(self.host.run("nginx -t").rc, 0)
    def test_nginx_service(self):
        service = self.host.service("nginx")
        self.assertTrue(service.is_running)
        self.assertTrue(service.is_enabled)
if __name__ == "__main__":
    unittest.main()

$ python test.py
..
----------------------------------------------------------------------
Ran 2 tests in 0.705s
OK

vagrant ssh-config > .vagrant/ssh-config
py.test --hosts=default --ssh-config=.vagrant/ssh-config tests.py

pip install pytest-testinfra paramiko
vagrant up
vagrant ssh-config > .vagrant/ssh-config
py.test --hosts=default --ssh-config=.vagrant/ssh-config --junit-xml junit.xml tests.py

$ py.test -qq --nagios --tb line test_ok.py; echo $?
TESTINFRA OK - 2 passed, 0 failed, 0 skipped in 2.30 seconds
..
0
$ py.test -qq --nagios --tb line test_fail.py; echo $?
TESTINFRA CRITICAL - 1 passed, 1 failed, 0 skipped in 2.24 seconds
.F
/usr/lib/python3/dist-packages/example/example.py:95: error: [Errno 111] error msg
2

verifier:
  name: shell
  command: py.test --hosts="paramiko://${KITCHEN_USERNAME}@${KITCHEN_HOSTNAME}:${KITCHEN_PORT}?ssh_identity_file=${KITCHEN_SSH_KEY}" --junit-xml "junit-${KITCHEN_INSTANCE}.xml" "test/integration/${KITCHEN_SUITE}"

import pytest
import subprocess
import testinfra
# scope='session' uses the same container for all the tests;
# scope='function' uses a new container per test function.
@pytest.fixture(scope='session')
def host(request):
    # build local ./Dockerfile
    subprocess.check_call(['docker', 'build', '-t', 'myimage', '.'])
    # run a container
    docker_id = subprocess.check_output(
        ['docker', 'run', '-d', 'myimage']).decode().strip()
    # return a testinfra connection to the container
    yield testinfra.get_host("docker://" + docker_id)
    # at the end of the test suite, destroy the container
    subprocess.check_call(['docker', 'rm', '-f', docker_id])
def test_myimage(host):
    # 'host' now binds to the container
    assert host.check_output('myapp -v') == 'Myapp 1.0'