def test_filters():
random_label_value = random_name()
containers_with_labels = []
for _ in range(3):
containers_with_labels.append(
docker.run(
"busybox",
["sleep", "infinity"],
remove=True,
detach=True,
labels=dict(dodo=random_label_value),
))
containers_with_wrong_labels = []
for _ in range(3):
containers_with_wrong_labels.append(
docker.run(
"busybox",
["sleep", "infinity"],
remove=True,
detach=True,
labels=dict(dodo="something"),
))
expected_containers_with_labels = docker.container.list(filters=dict(
label=f"dodo={random_label_value}"))
assert set(expected_containers_with_labels) == set(containers_with_labels)
for container in containers_with_labels + containers_with_wrong_labels:
container.kill()
def test_clone():
some_volume = docker.volume.create()
docker.run(
"busybox",
[
"sh",
"-c",
"mkdir -p /volume/subdir/subdir2 && touch /volume/subdir/subdir2/dodo.txt",
],
remove=True,
volumes=[(some_volume, "/volume")],
)
new_volume = docker.volume.clone(some_volume)
files = docker.run(
"busybox",
[
"sh",
"-c",
"ls /volume/subdir/subdir2",
],
remove=True,
volumes=[(new_volume, "/volume")],
)
assert files == "dodo.txt"
def test_run_volumes():
volume_name = random_name()
docker.run(
"busybox",
["touch", "/some/path/dodo"],
volumes=[(volume_name, "/some/path")],
remove=True,
)
docker.volume.remove(volume_name)
def __init_memory(self, loc):
try:
docker.run("redis",
volumes=[(loc + "/", '/data')],
publish=[(self.port, 6379)],
detach=True,
name='Prophet-Memory')
except:
docker.start('Prophet-Memory')
print('Prophet is alive')
def test_wait_multiple_container_random_exit_order():
cont_1 = docker.run("busybox", ["sh", "-c", "sleep 4 && exit 8"],
detach=True)
cont_2 = docker.run("busybox", ["sh", "-c", "sleep 2 && exit 10"],
detach=True)
with cont_1, cont_2:
exit_codes = docker.wait([cont_1, cont_2])
assert exit_codes == [8, 10]
def test_copy_to_volume(tmp_path):
some_volume = docker.volume.create()
docker.run(
"busybox",
["touch", "/volume/dodo.txt"],
remove=True,
volumes=[(some_volume, "/volume")],
)
docker.volume.copy((some_volume, "dodo.txt"), tmp_path)
assert (tmp_path / "dodo.txt").exists()
def init_tts():
global TEXT_TO_SPEECH, TTS_PORT
try:
docker.run(TEXT_TO_SPEECH,
detach=True,
networks=['host'],
name='Prophets-Voice')
print("TTS started in port {}".format(TTS_PORT))
except Exception as e:
docker.start('Prophets-Voice')
print("TTS Already running")
def init_stt():
global SPEECH_TO_TEXT, STT_PORT
try:
docker.run(SPEECH_TO_TEXT,
detach=True,
publish=[(STT_PORT, 5000)],
name='Prophets-Ears')
print("STT started in port {}".format(STT_PORT))
except:
docker.start('Prophets-Ears')
print('STT already running')
def test_volume_drivers():
some_volume = docker.volume.create(
driver="local",
options=dict(type="tmpfs", device="tmpfs", o="size=100m,uid=1000"),
)
docker.run(
"busybox",
["touch", "/dodo/dada"],
volumes=[(some_volume, "/dodo")],
remove=True,
)
docker.volume.remove(some_volume)
def test_context_manager():
with pytest.raises(DockerException):
with docker.network.create(random_name()) as my_net:
docker.run(
"busybox",
["ping", "idonotexistatall.com"],
networks=[my_net],
remove=True,
)
# an exception will be raised because the container will fail
# but the network will be removed anyway.
assert my_net not in docker.network.list()
def test_prune_prunes_container():
stopped_container = docker.run("hello-world", remove=False, detach=True)
running_container = docker.run(
"ubuntu", ["sleep", "infinity"], remove=False, detach=True
)
assert stopped_container in docker.container.list(all=True)
assert running_container in docker.container.list()
docker.system.prune()
assert stopped_container not in docker.container.list(all=True)
assert running_container in docker.container.list()
docker.container.remove(running_container, force=True)
def test_prune_prunes_volumes():
some_volume = docker.volume.create(driver="local")
docker.run(
"ubuntu",
["touch", "/dodo/dada"],
volumes=[(some_volume, "/dodo")],
remove=False,
)
assert some_volume in docker.volume.list()
docker.system.prune()
assert some_volume in docker.volume.list()
docker.system.prune(volumes=True)
assert some_volume not in docker.volume.list()
def test_copy_to_volume_subdirectory(tmp_path):
some_volume = docker.volume.create()
docker.run(
"busybox",
[
"sh",
"-c",
"mkdir -p /volume/subdir/subdir2 && touch /volume/subdir/subdir2/dodo.txt",
],
remove=True,
volumes=[(some_volume, "/volume")],
)
docker.volume.copy((some_volume, "subdir/subdir2"), tmp_path)
assert (tmp_path / "subdir2/dodo.txt").exists()
def test_wait_single_container():
cont_1 = docker.run("busybox", ["sh", "-c", "sleep 2 && exit 8"],
detach=True)
with cont_1:
exit_code = docker.wait(cont_1)
assert exit_code == 8
def test_execute():
my_container = docker.run("busybox:1", ["sleep", "infinity"],
detach=True,
remove=True)
exec_result = docker.execute(my_container, ["echo", "dodo"])
assert exec_result == "dodo"
docker.kill(my_container)
def test_client(report_dir: Path, request: Any) -> None:
try:
print("Starting autobahn-testsuite server")
autobahn_container = docker.run(
detach=True,
image="autobahn-testsuite",
name="autobahn",
publish=[(9001, 9001)],
remove=True,
volumes=[
(f"{request.fspath.dirname}/client", "/config"),
(f"{report_dir}", "/reports"),
],
)
print("Running aiohttp test client")
client = subprocess.Popen(
["wait-for-it", "-s", "localhost:9001", "--"] + [sys.executable] +
["tests/autobahn/client/client.py"])
client.wait()
finally:
print("Stopping client and server")
client.terminate()
client.wait()
autobahn_container.stop()
failed_messages = get_failed_tests(f"{report_dir}/clients", "aiohttp")
assert not failed_messages, "\n".join("\n\t".join(
f"{field}: {msg[field]}"
for field in ("case", "description", "expectation", "expected",
"received")) for msg in failed_messages)
def _docker_registry(login=True):
encrypted_password = docker.run(
"mhenry07/apache2-utils",
["htpasswd", "-Bbn", "my_user", "my_password"],
remove=True,
)
with tempfile.TemporaryDirectory() as tmp_path:
tmp_path = Path(tmp_path)
htpasswd_file = tmp_path / "htpasswd"
htpasswd_file.write_text(encrypted_password)
registry = docker.container.create(
"registry:2",
remove=True,
envs=dict(
REGISTRY_AUTH="htpasswd",
REGISTRY_AUTH_HTPASSWD_REALM="Registry Realm",
REGISTRY_AUTH_HTPASSWD_PATH="/tmp/htpasswd",
),
publish=[(5000, 5000)],
)
with registry:
registry.copy_to(htpasswd_file, "/tmp/htpasswd")
registry.start()
time.sleep(1.5)
if login:
docker.login("localhost:5000",
username="******",
password="******")
yield "localhost:5000"
def test_simple_logs_stream_stdout_and_stderr():
with docker.run("busybox:1", ["sh", "-c", ">&2 echo dodo && echo dudu"],
detach=True) as c:
time.sleep(0.3)
output = list(docker.container.logs(c, stream=True))
# the order of stderr and stdout is not guaranteed.
assert set(output) == {("stderr", b"dodo\n"), ("stdout", b"dudu\n")}
def test_restart():
cmd = ["sleep", "infinity"]
containers = [docker.run("busybox:1", cmd, detach=True) for _ in range(3)]
docker.kill(containers)
docker.restart(containers)
for container in containers:
assert container.state.running
def test_export_file(tmp_path):
dest = tmp_path / "dodo.tar"
with docker.run("ubuntu", ["sleep", "infinity"], detach=True,
remove=True) as c:
c.export(dest)
assert dest.exists()
assert dest.stat().st_size > 10_000
def test_exec_privilged_flag():
with docker.run("ubuntu:18.04", ["sleep", "infinity"],
detach=True,
remove=True) as c:
c.execute(["apt-get", "update"])
c.execute(["apt-get", "install", "-y", "iproute2"])
c.execute(["ip", "link", "add", "dummy0", "type", "dummy"],
privileged=True)
c.execute(["ip", "link", "delete", "dummy0"], privileged=True)
def test_exec_env_file(tmp_path):
env_file = tmp_path / "variables.env"
env_file.write_text("DODO=dada\n")
with docker.run("ubuntu", ["sleep", "infinity"], detach=True,
remove=True) as c:
result = c.execute(["bash", "-c", "echo $DODO"], env_files=[env_file])
assert result == "dada"
def test_execute_stream():
my_container = docker.run("busybox:1", ["sleep", "infinity"],
detach=True,
remove=True)
exec_result = list(
docker.execute(my_container, ["sh", "-c", ">&2 echo dodo"],
stream=True))
assert exec_result == [("stderr", b"dodo\n")]
docker.kill(my_container)
def test_docker_stats():
with docker.run("busybox", ["sleep", "infinity"],
detach=True,
stop_timeout=1) as container:
for stat in docker.stats():
if stat.container_id == container.id:
break
assert stat.container_name == container.name
assert stat.cpu_percentage <= 5
assert stat.memory_used <= 100_000_000
def test_same_stream_run_create_start():
python_code = """
import sys
sys.stdout.write("everything is fine\\n\\nhello world")
sys.stderr.write("Something is wrong!")
"""
image = build_image_running(python_code)
output_run = set(docker.run(image, remove=True, stream=True))
container = docker.container.create(image, remove=True)
output_create = set(container.start(attach=True, stream=True))
assert output_run == output_create
def test_remove_anonymous_volume_too():
container = docker.run("postgres:9.6.20-alpine", detach=True)
volume_id = container.mounts[0].name
volume = docker.volume.inspect(volume_id)
with container:
pass
assert volume not in docker.volume.list()
assert container not in docker.ps(all=True)
def test_container_run_with_random_port():
with docker.run(
"ubuntu",
["sleep", "infinity"],
publish=[(90, )],
remove=True,
detach=True,
stop_timeout=1,
) as container:
assert container.network_settings.ports["90/tcp"][0][
"HostPort"] is not None
def test_context_manager():
container_name = random_name()
with pytest.raises(ArithmeticError):
with docker.run("busybox:1", ["sleep", "infinity"],
detach=True,
name=container_name):
raise ArithmeticError
assert container_name not in [
x.name for x in docker.container.list(all=True)
]
def test_pause_unpause():
container = docker.run("busybox", ["ping", "www.google.com"],
detach=True,
remove=True)
with container:
assert container.state.running
container.pause()
assert container.state.paused
container.unpause()
assert not container.state.paused
assert container.state.running
def test_diff():
my_container = docker.run("busybox:1", ["sleep", "infinity"],
detach=True,
remove=True)
docker.execute(my_container, ["mkdir", "/some_path"])
docker.execute(my_container, ["touch", "/some_file"])
docker.execute(my_container, ["rm", "-rf", "/tmp"])
diff = docker.diff(my_container)
assert diff == {"/some_path": "A", "/some_file": "A", "/tmp": "D"}
docker.kill(my_container)
