diff --git a/tests/acceptance/cli_test.py b/tests/acceptance/cli_test.py
index 74c4e0159..c06471650 100644
--- a/tests/acceptance/cli_test.py
+++ b/tests/acceptance/cli_test.py
@@ -474,9 +474,9 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'])
result = self.dispatch(['ps'])
- self.assertIn('multiplecomposefiles_simple_1', result.stdout)
- self.assertIn('multiplecomposefiles_another_1', result.stdout)
- self.assertNotIn('multiplecomposefiles_yetanother_1', result.stdout)
+ assert 'multiplecomposefiles_simple_1' in result.stdout
+ assert 'multiplecomposefiles_another_1' in result.stdout
+ assert 'multiplecomposefiles_yetanother_1' not in result.stdout
def test_ps_alternate_composefile(self):
config_path = os.path.abspath(
@@ -487,9 +487,9 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['-f', 'compose2.yml', 'up', '-d'])
result = self.dispatch(['-f', 'compose2.yml', 'ps'])
- self.assertNotIn('multiplecomposefiles_simple_1', result.stdout)
- self.assertNotIn('multiplecomposefiles_another_1', result.stdout)
- self.assertIn('multiplecomposefiles_yetanother_1', result.stdout)
+ assert 'multiplecomposefiles_simple_1' not in result.stdout
+ assert 'multiplecomposefiles_another_1' not in result.stdout
+ assert 'multiplecomposefiles_yetanother_1' in result.stdout
def test_pull(self):
result = self.dispatch(['pull'])
@@ -528,13 +528,16 @@ class CLITestCase(DockerClientTestCase):
returncode=1
)
- self.assertRegexpMatches(result.stderr, re.compile('^Pulling simple', re.MULTILINE))
- self.assertRegexpMatches(result.stderr, re.compile('^Pulling another', re.MULTILINE))
- self.assertRegexpMatches(result.stderr,
- re.compile('^ERROR: for another .*does not exist.*', re.MULTILINE))
- self.assertRegexpMatches(result.stderr,
- re.compile('''^(ERROR: )?(b')?.* nonexisting-image''',
- re.MULTILINE))
+ assert re.search(re.compile('^Pulling simple', re.MULTILINE), result.stderr)
+ assert re.search(re.compile('^Pulling another', re.MULTILINE), result.stderr)
+ assert re.search(
+ re.compile('^ERROR: for another .*does not exist.*', re.MULTILINE),
+ result.stderr
+ )
+ assert re.search(
+ re.compile('''^(ERROR: )?(b')?.* nonexisting-image''', re.MULTILINE),
+ result.stderr
+ )
def test_build_plain(self):
self.base_dir = 'tests/fixtures/simple-dockerfile'
@@ -573,7 +576,6 @@ class CLITestCase(DockerClientTestCase):
assert BUILD_CACHE_TEXT not in result.stdout
assert BUILD_PULL_TEXT in result.stdout
- @pytest.mark.xfail(reason='17.10.0 RC bug remove after GA https://github.com/moby/moby/issues/35116')
def test_build_failed(self):
self.base_dir = 'tests/fixtures/simple-failing-dockerfile'
self.dispatch(['build', 'simple'], returncode=1)
@@ -587,7 +589,6 @@ class CLITestCase(DockerClientTestCase):
]
assert len(containers) == 1
- @pytest.mark.xfail(reason='17.10.0 RC bug remove after GA https://github.com/moby/moby/issues/35116')
def test_build_failed_forcerm(self):
self.base_dir = 'tests/fixtures/simple-failing-dockerfile'
self.dispatch(['build', '--force-rm', 'simple'], returncode=1)
@@ -809,36 +810,36 @@ class CLITestCase(DockerClientTestCase):
def test_down_timeout(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
""
self.dispatch(['down', '-t', '1'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
+ assert len(service.containers(stopped=True)) == 0
def test_down_signal(self):
self.base_dir = 'tests/fixtures/stop-signal-composefile'
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
self.dispatch(['down', '-t', '1'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
+ assert len(service.containers(stopped=True)) == 0
def test_up_detached(self):
self.dispatch(['up', '-d'])
service = self.project.get_service('simple')
another = self.project.get_service('another')
- self.assertEqual(len(service.containers()), 1)
- self.assertEqual(len(another.containers()), 1)
+ assert len(service.containers()) == 1
+ assert len(another.containers()) == 1
# Ensure containers don't have stdin and stdout connected in -d mode
container, = service.containers()
- self.assertFalse(container.get('Config.AttachStderr'))
- self.assertFalse(container.get('Config.AttachStdout'))
- self.assertFalse(container.get('Config.AttachStdin'))
+ assert not container.get('Config.AttachStderr')
+ assert not container.get('Config.AttachStdout')
+ assert not container.get('Config.AttachStdin')
def test_up_attached(self):
self.base_dir = 'tests/fixtures/echo-services'
@@ -858,7 +859,7 @@ class CLITestCase(DockerClientTestCase):
network_name = self.project.networks.networks['default'].full_name
networks = self.client.networks(names=[network_name])
- self.assertEqual(len(networks), 1)
+ assert len(networks) == 1
assert networks[0]['Driver'] == 'bridge' if not is_cluster(self.client) else 'overlay'
assert 'com.docker.network.bridge.enable_icc' not in networks[0]['Options']
@@ -866,17 +867,17 @@ class CLITestCase(DockerClientTestCase):
for service in services:
containers = service.containers()
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
container = containers[0]
- self.assertIn(container.id, network['Containers'])
+ assert container.id in network['Containers']
networks = container.get('NetworkSettings.Networks')
- self.assertEqual(list(networks), [network['Name']])
+ assert list(networks) == [network['Name']]
- self.assertEqual(
- sorted(networks[network['Name']]['Aliases']),
- sorted([service.name, container.short_id]))
+ assert sorted(networks[network['Name']]['Aliases']) == sorted(
+ [service.name, container.short_id]
+ )
for service in services:
assert self.lookup(container, service.name)
@@ -1213,13 +1214,13 @@ class CLITestCase(DockerClientTestCase):
console = self.project.get_service('console')
# console was not started
- self.assertEqual(len(web.containers()), 1)
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(console.containers()), 0)
+ assert len(web.containers()) == 1
+ assert len(db.containers()) == 1
+ assert len(console.containers()) == 0
# web has links
web_container = web.containers()[0]
- self.assertTrue(web_container.get('HostConfig.Links'))
+ assert web_container.get('HostConfig.Links')
def test_up_with_net_is_invalid(self):
self.base_dir = 'tests/fixtures/net-container'
@@ -1241,8 +1242,9 @@ class CLITestCase(DockerClientTestCase):
foo = self.project.get_service('foo')
foo_container = foo.containers()[0]
- assert foo_container.get('HostConfig.NetworkMode') == \
- 'container:{}'.format(bar_container.id)
+ assert foo_container.get('HostConfig.NetworkMode') == 'container:{}'.format(
+ bar_container.id
+ )
@v3_only()
def test_up_with_healthcheck(self):
@@ -1294,37 +1296,37 @@ class CLITestCase(DockerClientTestCase):
web = self.project.get_service('web')
db = self.project.get_service('db')
console = self.project.get_service('console')
- self.assertEqual(len(web.containers()), 1)
- self.assertEqual(len(db.containers()), 0)
- self.assertEqual(len(console.containers()), 0)
+ assert len(web.containers()) == 1
+ assert len(db.containers()) == 0
+ assert len(console.containers()) == 0
def test_up_with_force_recreate(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
old_ids = [c.id for c in service.containers()]
self.dispatch(['up', '-d', '--force-recreate'], None)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
new_ids = [c.id for c in service.containers()]
- self.assertNotEqual(old_ids, new_ids)
+ assert old_ids != new_ids
def test_up_with_no_recreate(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
old_ids = [c.id for c in service.containers()]
self.dispatch(['up', '-d', '--no-recreate'], None)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
new_ids = [c.id for c in service.containers()]
- self.assertEqual(old_ids, new_ids)
+ assert old_ids == new_ids
def test_up_with_force_recreate_and_no_recreate(self):
self.dispatch(
@@ -1365,14 +1367,14 @@ class CLITestCase(DockerClientTestCase):
proc = start_process(self.base_dir, ['up', '--abort-on-container-exit'])
wait_on_condition(ContainerCountCondition(self.project, 0))
proc.wait()
- self.assertEqual(proc.returncode, 0)
+ assert proc.returncode == 0
def test_up_handles_abort_on_container_exit_code(self):
self.base_dir = 'tests/fixtures/abort-on-container-exit-1'
proc = start_process(self.base_dir, ['up', '--abort-on-container-exit'])
wait_on_condition(ContainerCountCondition(self.project, 0))
proc.wait()
- self.assertEqual(proc.returncode, 1)
+ assert proc.returncode == 1
@v2_only()
@no_cluster('Container PID mode does not work across clusters')
@@ -1403,27 +1405,27 @@ class CLITestCase(DockerClientTestCase):
def test_exec_without_tty(self):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['up', '-d', 'console'])
- self.assertEqual(len(self.project.containers()), 1)
+ assert len(self.project.containers()) == 1
stdout, stderr = self.dispatch(['exec', '-T', 'console', 'ls', '-1d', '/'])
- self.assertEqual(stderr, "")
- self.assertEqual(stdout, "/\n")
+ assert stderr == ""
+ assert stdout == "/\n"
def test_exec_custom_user(self):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['up', '-d', 'console'])
- self.assertEqual(len(self.project.containers()), 1)
+ assert len(self.project.containers()) == 1
stdout, stderr = self.dispatch(['exec', '-T', '--user=operator', 'console', 'whoami'])
- self.assertEqual(stdout, "operator\n")
- self.assertEqual(stderr, "")
+ assert stdout == "operator\n"
+ assert stderr == ""
@v2_2_only()
def test_exec_service_with_environment_overridden(self):
name = 'service'
self.base_dir = 'tests/fixtures/environment-exec'
self.dispatch(['up', '-d'])
- self.assertEqual(len(self.project.containers()), 1)
+ assert len(self.project.containers()) == 1
stdout, stderr = self.dispatch([
'exec',
@@ -1441,27 +1443,27 @@ class CLITestCase(DockerClientTestCase):
# added option from command line
assert 'alpha=beta' in stdout
- self.assertEqual(stderr, '')
+ assert stderr == ''
def test_run_service_without_links(self):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['run', 'console', '/bin/true'])
- self.assertEqual(len(self.project.containers()), 0)
+ assert len(self.project.containers()) == 0
# Ensure stdin/out was open
container = self.project.containers(stopped=True, one_off=OneOffFilter.only)[0]
config = container.inspect()['Config']
- self.assertTrue(config['AttachStderr'])
- self.assertTrue(config['AttachStdout'])
- self.assertTrue(config['AttachStdin'])
+ assert config['AttachStderr']
+ assert config['AttachStdout']
+ assert config['AttachStdin']
def test_run_service_with_links(self):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['run', 'web', '/bin/true'], None)
db = self.project.get_service('db')
console = self.project.get_service('console')
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(console.containers()), 0)
+ assert len(db.containers()) == 1
+ assert len(console.containers()) == 0
@v2_only()
def test_run_service_with_dependencies(self):
@@ -1469,8 +1471,8 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', 'web', '/bin/true'], None)
db = self.project.get_service('db')
console = self.project.get_service('console')
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(console.containers()), 0)
+ assert len(db.containers()) == 1
+ assert len(console.containers()) == 0
def test_run_service_with_scaled_dependencies(self):
self.base_dir = 'tests/fixtures/v2-dependencies'
@@ -1487,22 +1489,22 @@ class CLITestCase(DockerClientTestCase):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['run', '--no-deps', 'web', '/bin/true'])
db = self.project.get_service('db')
- self.assertEqual(len(db.containers()), 0)
+ assert len(db.containers()) == 0
def test_run_does_not_recreate_linked_containers(self):
self.base_dir = 'tests/fixtures/links-composefile'
self.dispatch(['up', '-d', 'db'])
db = self.project.get_service('db')
- self.assertEqual(len(db.containers()), 1)
+ assert len(db.containers()) == 1
old_ids = [c.id for c in db.containers()]
self.dispatch(['run', 'web', '/bin/true'], None)
- self.assertEqual(len(db.containers()), 1)
+ assert len(db.containers()) == 1
new_ids = [c.id for c in db.containers()]
- self.assertEqual(old_ids, new_ids)
+ assert old_ids == new_ids
def test_run_without_command(self):
self.base_dir = 'tests/fixtures/commands-composefile'
@@ -1511,18 +1513,12 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', 'implicit'])
service = self.project.get_service('implicit')
containers = service.containers(stopped=True, one_off=OneOffFilter.only)
- self.assertEqual(
- [c.human_readable_command for c in containers],
- [u'/bin/sh -c echo "success"'],
- )
+ assert [c.human_readable_command for c in containers] == [u'/bin/sh -c echo "success"']
self.dispatch(['run', 'explicit'])
service = self.project.get_service('explicit')
containers = service.containers(stopped=True, one_off=OneOffFilter.only)
- self.assertEqual(
- [c.human_readable_command for c in containers],
- [u'/bin/true'],
- )
+ assert [c.human_readable_command for c in containers] == [u'/bin/true']
@pytest.mark.skipif(SWARM_SKIP_RM_VOLUMES, reason='Swarm DELETE /containers/<id> bug')
def test_run_rm(self):
@@ -1534,7 +1530,7 @@ class CLITestCase(DockerClientTestCase):
'running'))
service = self.project.get_service('test')
containers = service.containers(one_off=OneOffFilter.only)
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
mounts = containers[0].get('Mounts')
for mount in mounts:
if mount['Destination'] == '/container-path':
@@ -1543,7 +1539,7 @@ class CLITestCase(DockerClientTestCase):
os.kill(proc.pid, signal.SIGINT)
wait_on_process(proc, 1)
- self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+ assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
volumes = self.client.volumes()['Volumes']
assert volumes is not None
@@ -1611,7 +1607,7 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', '--user={user}'.format(user=user), name], returncode=1)
service = self.project.get_service(name)
container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
- self.assertEqual(user, container.get('Config.User'))
+ assert user == container.get('Config.User')
def test_run_service_with_user_overridden_short_form(self):
self.base_dir = 'tests/fixtures/user-composefile'
@@ -1620,7 +1616,7 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', '-u', user, name], returncode=1)
service = self.project.get_service(name)
container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
- self.assertEqual(user, container.get('Config.User'))
+ assert user == container.get('Config.User')
def test_run_service_with_environment_overridden(self):
name = 'service'
@@ -1635,13 +1631,13 @@ class CLITestCase(DockerClientTestCase):
service = self.project.get_service(name)
container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
# env overridden
- self.assertEqual('notbar', container.environment['foo'])
+ assert 'notbar' == container.environment['foo']
# keep environment from yaml
- self.assertEqual('world', container.environment['hello'])
+ assert 'world' == container.environment['hello']
# added option from command line
- self.assertEqual('beta', container.environment['alpha'])
+ assert 'beta' == container.environment['alpha']
# make sure a value with a = don't crash out
- self.assertEqual('moto=bobo', container.environment['allo'])
+ assert 'moto=bobo' == container.environment['allo']
def test_run_service_without_map_ports(self):
# create one off container
@@ -1657,8 +1653,8 @@ class CLITestCase(DockerClientTestCase):
container.stop()
# check the ports
- self.assertEqual(port_random, None)
- self.assertEqual(port_assigned, None)
+ assert port_random is None
+ assert port_assigned is None
def test_run_service_with_map_ports(self):
# create one off container
@@ -1716,8 +1712,8 @@ class CLITestCase(DockerClientTestCase):
container.stop()
# check the ports
- self.assertEqual(port_short, "127.0.0.1:30000")
- self.assertEqual(port_full, "127.0.0.1:30001")
+ assert port_short == "127.0.0.1:30000"
+ assert port_full == "127.0.0.1:30001"
def test_run_with_expose_ports(self):
# create one off container
@@ -1726,7 +1722,7 @@ class CLITestCase(DockerClientTestCase):
container = self.project.get_service('simple').containers(one_off=OneOffFilter.only)[0]
ports = container.ports
- self.assertEqual(len(ports), 9)
+ assert len(ports) == 9
# exposed ports are not mapped to host ports
assert ports['3000/tcp'] is None
assert ports['3001/tcp'] is None
@@ -1748,7 +1744,7 @@ class CLITestCase(DockerClientTestCase):
service = self.project.get_service('service')
container, = service.containers(stopped=True, one_off=OneOffFilter.only)
- self.assertEqual(container.name, name)
+ assert container.name == name
def test_run_service_with_workdir_overridden(self):
self.base_dir = 'tests/fixtures/run-workdir'
@@ -1757,7 +1753,7 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', '--workdir={workdir}'.format(workdir=workdir), name])
service = self.project.get_service(name)
container = service.containers(stopped=True, one_off=True)[0]
- self.assertEqual(workdir, container.get('Config.WorkingDir'))
+ assert workdir == container.get('Config.WorkingDir')
def test_run_service_with_workdir_overridden_short_form(self):
self.base_dir = 'tests/fixtures/run-workdir'
@@ -1766,7 +1762,7 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['run', '-w', workdir, name])
service = self.project.get_service(name)
container = service.containers(stopped=True, one_off=True)[0]
- self.assertEqual(workdir, container.get('Config.WorkingDir'))
+ assert workdir == container.get('Config.WorkingDir')
@v2_only()
def test_run_interactive_connects_to_network(self):
@@ -1887,19 +1883,19 @@ class CLITestCase(DockerClientTestCase):
service = self.project.get_service('simple')
service.create_container()
kill_service(service)
- self.assertEqual(len(service.containers(stopped=True)), 1)
+ assert len(service.containers(stopped=True)) == 1
self.dispatch(['rm', '--force'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
+ assert len(service.containers(stopped=True)) == 0
service = self.project.get_service('simple')
service.create_container()
kill_service(service)
- self.assertEqual(len(service.containers(stopped=True)), 1)
+ assert len(service.containers(stopped=True)) == 1
self.dispatch(['rm', '-f'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
+ assert len(service.containers(stopped=True)) == 0
service = self.project.get_service('simple')
service.create_container()
self.dispatch(['rm', '-fs'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
+ assert len(service.containers(stopped=True)) == 0
def test_rm_stop(self):
self.dispatch(['up', '-d'], None)
@@ -1923,43 +1919,43 @@ class CLITestCase(DockerClientTestCase):
service.create_container(one_off=False)
service.create_container(one_off=True)
kill_service(service)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 1)
+ assert len(service.containers(stopped=True)) == 1
+ assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 1
self.dispatch(['rm', '-f'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
- self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+ assert len(service.containers(stopped=True)) == 0
+ assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
service.create_container(one_off=False)
service.create_container(one_off=True)
kill_service(service)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 1)
+ assert len(service.containers(stopped=True)) == 1
+ assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 1
self.dispatch(['rm', '-f', '--all'], None)
- self.assertEqual(len(service.containers(stopped=True)), 0)
- self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+ assert len(service.containers(stopped=True)) == 0
+ assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
def test_stop(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
self.dispatch(['stop', '-t', '1'], None)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertFalse(service.containers(stopped=True)[0].is_running)
+ assert len(service.containers(stopped=True)) == 1
+ assert not service.containers(stopped=True)[0].is_running
def test_stop_signal(self):
self.base_dir = 'tests/fixtures/stop-signal-composefile'
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
self.dispatch(['stop', '-t', '1'], None)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertFalse(service.containers(stopped=True)[0].is_running)
- self.assertEqual(service.containers(stopped=True)[0].exit_code, 0)
+ assert len(service.containers(stopped=True)) == 1
+ assert not service.containers(stopped=True)[0].is_running
+ assert service.containers(stopped=True)[0].exit_code == 0
def test_start_no_containers(self):
result = self.dispatch(['start'], returncode=1)
@@ -1971,39 +1967,39 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'])
simple = self.project.get_service('simple').containers()[0]
log_config = simple.get('HostConfig.LogConfig')
- self.assertTrue(log_config)
- self.assertEqual(log_config.get('Type'), 'none')
+ assert log_config
+ assert log_config.get('Type') == 'none'
another = self.project.get_service('another').containers()[0]
log_config = another.get('HostConfig.LogConfig')
- self.assertTrue(log_config)
- self.assertEqual(log_config.get('Type'), 'json-file')
- self.assertEqual(log_config.get('Config')['max-size'], '10m')
+ assert log_config
+ assert log_config.get('Type') == 'json-file'
+ assert log_config.get('Config')['max-size'] == '10m'
def test_up_logging_legacy(self):
self.base_dir = 'tests/fixtures/logging-composefile-legacy'
self.dispatch(['up', '-d'])
simple = self.project.get_service('simple').containers()[0]
log_config = simple.get('HostConfig.LogConfig')
- self.assertTrue(log_config)
- self.assertEqual(log_config.get('Type'), 'none')
+ assert log_config
+ assert log_config.get('Type') == 'none'
another = self.project.get_service('another').containers()[0]
log_config = another.get('HostConfig.LogConfig')
- self.assertTrue(log_config)
- self.assertEqual(log_config.get('Type'), 'json-file')
- self.assertEqual(log_config.get('Config')['max-size'], '10m')
+ assert log_config
+ assert log_config.get('Type') == 'json-file'
+ assert log_config.get('Config')['max-size'] == '10m'
def test_pause_unpause(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertFalse(service.containers()[0].is_paused)
+ assert not service.containers()[0].is_paused
self.dispatch(['pause'], None)
- self.assertTrue(service.containers()[0].is_paused)
+ assert service.containers()[0].is_paused
self.dispatch(['unpause'], None)
- self.assertFalse(service.containers()[0].is_paused)
+ assert not service.containers()[0].is_paused
def test_pause_no_containers(self):
result = self.dispatch(['pause'], returncode=1)
@@ -2077,7 +2073,7 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'])
result = self.dispatch(['logs', '-f', '-t'])
- self.assertRegexpMatches(result.stdout, '(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})')
+ assert re.search('(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})', result.stdout)
def test_logs_tail(self):
self.base_dir = 'tests/fixtures/logs-tail-composefile'
@@ -2092,36 +2088,36 @@ class CLITestCase(DockerClientTestCase):
def test_kill(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
self.dispatch(['kill'], None)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertFalse(service.containers(stopped=True)[0].is_running)
+ assert len(service.containers(stopped=True)) == 1
+ assert not service.containers(stopped=True)[0].is_running
def test_kill_signal_sigstop(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
self.dispatch(['kill', '-s', 'SIGSTOP'], None)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
# The container is still running. It has only been paused
- self.assertTrue(service.containers()[0].is_running)
+ assert service.containers()[0].is_running
def test_kill_stopped_service(self):
self.dispatch(['up', '-d'], None)
service = self.project.get_service('simple')
self.dispatch(['kill', '-s', 'SIGSTOP'], None)
- self.assertTrue(service.containers()[0].is_running)
+ assert service.containers()[0].is_running
self.dispatch(['kill', '-s', 'SIGKILL'], None)
- self.assertEqual(len(service.containers(stopped=True)), 1)
- self.assertFalse(service.containers(stopped=True)[0].is_running)
+ assert len(service.containers(stopped=True)) == 1
+ assert not service.containers(stopped=True)[0].is_running
def test_restart(self):
service = self.project.get_service('simple')
@@ -2130,23 +2126,17 @@ class CLITestCase(DockerClientTestCase):
started_at = container.dictionary['State']['StartedAt']
self.dispatch(['restart', '-t', '1'], None)
container.inspect()
- self.assertNotEqual(
- container.dictionary['State']['FinishedAt'],
- '0001-01-01T00:00:00Z',
- )
- self.assertNotEqual(
- container.dictionary['State']['StartedAt'],
- started_at,
- )
+ assert container.dictionary['State']['FinishedAt'] != '0001-01-01T00:00:00Z'
+ assert container.dictionary['State']['StartedAt'] != started_at
def test_restart_stopped_container(self):
service = self.project.get_service('simple')
container = service.create_container()
container.start()
container.kill()
- self.assertEqual(len(service.containers(stopped=True)), 1)
+ assert len(service.containers(stopped=True)) == 1
self.dispatch(['restart', '-t', '1'], None)
- self.assertEqual(len(service.containers(stopped=False)), 1)
+ assert len(service.containers(stopped=False)) == 1
def test_restart_no_containers(self):
result = self.dispatch(['restart'], returncode=1)
@@ -2156,23 +2146,23 @@ class CLITestCase(DockerClientTestCase):
project = self.project
self.dispatch(['scale', 'simple=1'])
- self.assertEqual(len(project.get_service('simple').containers()), 1)
+ assert len(project.get_service('simple').containers()) == 1
self.dispatch(['scale', 'simple=3', 'another=2'])
- self.assertEqual(len(project.get_service('simple').containers()), 3)
- self.assertEqual(len(project.get_service('another').containers()), 2)
+ assert len(project.get_service('simple').containers()) == 3
+ assert len(project.get_service('another').containers()) == 2
self.dispatch(['scale', 'simple=1', 'another=1'])
- self.assertEqual(len(project.get_service('simple').containers()), 1)
- self.assertEqual(len(project.get_service('another').containers()), 1)
+ assert len(project.get_service('simple').containers()) == 1
+ assert len(project.get_service('another').containers()) == 1
self.dispatch(['scale', 'simple=1', 'another=1'])
- self.assertEqual(len(project.get_service('simple').containers()), 1)
- self.assertEqual(len(project.get_service('another').containers()), 1)
+ assert len(project.get_service('simple').containers()) == 1
+ assert len(project.get_service('another').containers()) == 1
self.dispatch(['scale', 'simple=0', 'another=0'])
- self.assertEqual(len(project.get_service('simple').containers()), 0)
- self.assertEqual(len(project.get_service('another').containers()), 0)
+ assert len(project.get_service('simple').containers()) == 0
+ assert len(project.get_service('another').containers()) == 0
def test_scale_v2_2(self):
self.base_dir = 'tests/fixtures/scale'
@@ -2267,10 +2257,10 @@ class CLITestCase(DockerClientTestCase):
result = self.dispatch(['port', '--index=' + str(index), 'simple', str(number)])
return result.stdout.rstrip()
- self.assertEqual(get_port(3000), containers[0].get_local_port(3000))
- self.assertEqual(get_port(3000, index=1), containers[0].get_local_port(3000))
- self.assertEqual(get_port(3000, index=2), containers[1].get_local_port(3000))
- self.assertEqual(get_port(3002), "")
+ assert get_port(3000) == containers[0].get_local_port(3000)
+ assert get_port(3000, index=1) == containers[0].get_local_port(3000)
+ assert get_port(3000, index=2) == containers[1].get_local_port(3000)
+ assert get_port(3002) == ""
def test_events_json(self):
events_proc = start_process(self.base_dir, ['events', '--json'])
@@ -2321,8 +2311,8 @@ class CLITestCase(DockerClientTestCase):
self._project = get_project(self.base_dir, [config_path])
containers = self.project.containers(stopped=True)
- self.assertEqual(len(containers), 1)
- self.assertIn("FOO=1", containers[0].get('Config.Env'))
+ assert len(containers) == 1
+ assert "FOO=1" in containers[0].get('Config.Env')
@mock.patch.dict(os.environ)
def test_home_and_env_var_in_volume_path(self):
@@ -2342,11 +2332,11 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'], None)
containers = self.project.containers()
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
web, db = containers
- self.assertEqual(web.human_readable_command, 'top')
- self.assertEqual(db.human_readable_command, 'top')
+ assert web.human_readable_command == 'top'
+ assert db.human_readable_command == 'top'
def test_up_with_multiple_files(self):
self.base_dir = 'tests/fixtures/override-files'
@@ -2366,21 +2356,18 @@ class CLITestCase(DockerClientTestCase):
None)
containers = self.project.containers()
- self.assertEqual(len(containers), 3)
+ assert len(containers) == 3
web, other, db = containers
- self.assertEqual(web.human_readable_command, 'top')
- self.assertEqual(db.human_readable_command, 'top')
- self.assertEqual(other.human_readable_command, 'top')
+ assert web.human_readable_command == 'top'
+ assert db.human_readable_command == 'top'
+ assert other.human_readable_command == 'top'
def test_up_with_extends(self):
self.base_dir = 'tests/fixtures/extends'
self.dispatch(['up', '-d'], None)
- self.assertEqual(
- set([s.name for s in self.project.services]),
- set(['mydb', 'myweb']),
- )
+ assert set([s.name for s in self.project.services]) == set(['mydb', 'myweb'])
# Sort by name so we get [db, web]
containers = sorted(
@@ -2388,19 +2375,17 @@ class CLITestCase(DockerClientTestCase):
key=lambda c: c.name,
)
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
web = containers[1]
- self.assertEqual(
- set(get_links(web)),
- set(['db', 'mydb_1', 'extends_mydb_1']))
+ assert set(get_links(web)) == set(['db', 'mydb_1', 'extends_mydb_1'])
expected_env = set([
"FOO=1",
"BAR=2",
"BAZ=2",
])
- self.assertTrue(expected_env <= set(web.get('Config.Env')))
+ assert expected_env <= set(web.get('Config.Env'))
def test_top_services_not_running(self):
self.base_dir = 'tests/fixtures/top'
@@ -2412,9 +2397,9 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'])
result = self.dispatch(['top'])
- self.assertIn('top_service_a', result.stdout)
- self.assertIn('top_service_b', result.stdout)
- self.assertNotIn('top_not_a_service', result.stdout)
+ assert 'top_service_a' in result.stdout
+ assert 'top_service_b' in result.stdout
+ assert 'top_not_a_service' not in result.stdout
def test_top_processes_running(self):
self.base_dir = 'tests/fixtures/top'
@@ -2473,14 +2458,14 @@ class CLITestCase(DockerClientTestCase):
self.dispatch(['up', '-d'], None)
containers = self.project.containers()
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
web, db = containers
- self.assertEqual(web.human_readable_command, 'sleep 100')
- self.assertEqual(db.human_readable_command, 'top')
+ assert web.human_readable_command == 'sleep 100'
+ assert db.human_readable_command == 'top'
def test_up_with_duplicate_override_yaml_files(self):
self.base_dir = 'tests/fixtures/duplicate-override-yaml-files'
- with self.assertRaises(DuplicateOverrideFileFound):
+ with pytest.raises(DuplicateOverrideFileFound):
get_project(self.base_dir, [])
self.base_dir = None
diff --git a/tests/integration/project_test.py b/tests/integration/project_test.py
index 554998e1c..3180c1b9b 100644
--- a/tests/integration/project_test.py
+++ b/tests/integration/project_test.py
@@ -63,7 +63,7 @@ class ProjectTest(DockerClientTestCase):
project.up()
containers = project.containers()
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
@pytest.mark.skipif(SWARM_SKIP_CONTAINERS_ALL, reason='Swarm /containers/json bug')
def test_containers_stopped(self):
@@ -87,9 +87,7 @@ class ProjectTest(DockerClientTestCase):
project.up()
containers = project.containers(['web'])
- self.assertEqual(
- [c.name for c in containers],
- ['composetest_web_1'])
+ assert [c.name for c in containers] == ['composetest_web_1']
def test_containers_with_extra_service(self):
web = self.create_service('web')
@@ -101,10 +99,7 @@ class ProjectTest(DockerClientTestCase):
self.create_service('extra').create_container()
project = Project('composetest', [web, db], self.client)
- self.assertEqual(
- set(project.containers(stopped=True)),
- set([web_1, db_1]),
- )
+ assert set(project.containers(stopped=True)) == set([web_1, db_1])
def test_volumes_from_service(self):
project = Project.from_config(
@@ -123,7 +118,7 @@ class ProjectTest(DockerClientTestCase):
)
db = project.get_service('db')
data = project.get_service('data')
- self.assertEqual(db.volumes_from, [VolumeFromSpec(data, 'rw', 'service')])
+ assert db.volumes_from == [VolumeFromSpec(data, 'rw', 'service')]
def test_volumes_from_container(self):
data_container = Container.create(
@@ -145,7 +140,7 @@ class ProjectTest(DockerClientTestCase):
client=self.client,
)
db = project.get_service('db')
- self.assertEqual(db._get_volumes_from(), [data_container.id + ':rw'])
+ assert db._get_volumes_from() == [data_container.id + ':rw']
@v2_only()
@no_cluster('container networks not supported in Swarm')
@@ -173,7 +168,7 @@ class ProjectTest(DockerClientTestCase):
web = project.get_service('web')
net = project.get_service('net')
- self.assertEqual(web.network_mode.mode, 'container:' + net.containers()[0].id)
+ assert web.network_mode.mode == 'container:' + net.containers()[0].id
@v2_only()
@no_cluster('container networks not supported in Swarm')
@@ -212,7 +207,7 @@ class ProjectTest(DockerClientTestCase):
project.up()
web = project.get_service('web')
- self.assertEqual(web.network_mode.mode, 'container:' + net_container.id)
+ assert web.network_mode.mode == 'container:' + net_container.id
@no_cluster('container networks not supported in Swarm')
def test_net_from_service_v1(self):
@@ -236,7 +231,7 @@ class ProjectTest(DockerClientTestCase):
web = project.get_service('web')
net = project.get_service('net')
- self.assertEqual(web.network_mode.mode, 'container:' + net.containers()[0].id)
+ assert web.network_mode.mode == 'container:' + net.containers()[0].id
@no_cluster('container networks not supported in Swarm')
def test_net_from_container_v1(self):
@@ -271,7 +266,7 @@ class ProjectTest(DockerClientTestCase):
project.up()
web = project.get_service('web')
- self.assertEqual(web.network_mode.mode, 'container:' + net_container.id)
+ assert web.network_mode.mode == 'container:' + net_container.id
def test_start_pause_unpause_stop_kill_remove(self):
web = self.create_service('web')
@@ -280,53 +275,51 @@ class ProjectTest(DockerClientTestCase):
project.start()
- self.assertEqual(len(web.containers()), 0)
- self.assertEqual(len(db.containers()), 0)
+ assert len(web.containers()) == 0
+ assert len(db.containers()) == 0
web_container_1 = web.create_container()
web_container_2 = web.create_container()
db_container = db.create_container()
project.start(service_names=['web'])
- self.assertEqual(
- set(c.name for c in project.containers() if c.is_running),
- set([web_container_1.name, web_container_2.name]))
-
- project.start()
- self.assertEqual(
- set(c.name for c in project.containers() if c.is_running),
- set([web_container_1.name, web_container_2.name, db_container.name]))
-
- project.pause(service_names=['web'])
- self.assertEqual(
- set([c.name for c in project.containers() if c.is_paused]),
- set([web_container_1.name, web_container_2.name]))
-
- project.pause()
- self.assertEqual(
- set([c.name for c in project.containers() if c.is_paused]),
- set([web_container_1.name, web_container_2.name, db_container.name]))
-
- project.unpause(service_names=['db'])
- self.assertEqual(len([c.name for c in project.containers() if c.is_paused]), 2)
-
- project.unpause()
- self.assertEqual(len([c.name for c in project.containers() if c.is_paused]), 0)
-
- project.stop(service_names=['web'], timeout=1)
- self.assertEqual(
- set(c.name for c in project.containers() if c.is_running), set([db_container.name])
+ assert set(c.name for c in project.containers() if c.is_running) == set(
+ [web_container_1.name, web_container_2.name]
)
+ project.start()
+ assert set(c.name for c in project.containers() if c.is_running) == set(
+ [web_container_1.name, web_container_2.name, db_container.name]
+ )
+
+ project.pause(service_names=['web'])
+ assert set([c.name for c in project.containers() if c.is_paused]) == set(
+ [web_container_1.name, web_container_2.name]
+ )
+
+ project.pause()
+ assert set([c.name for c in project.containers() if c.is_paused]) == set(
+ [web_container_1.name, web_container_2.name, db_container.name]
+ )
+
+ project.unpause(service_names=['db'])
+ assert len([c.name for c in project.containers() if c.is_paused]) == 2
+
+ project.unpause()
+ assert len([c.name for c in project.containers() if c.is_paused]) == 0
+
+ project.stop(service_names=['web'], timeout=1)
+ assert set(c.name for c in project.containers() if c.is_running) == set([db_container.name])
+
project.kill(service_names=['db'])
- self.assertEqual(len([c for c in project.containers() if c.is_running]), 0)
- self.assertEqual(len(project.containers(stopped=True)), 3)
+ assert len([c for c in project.containers() if c.is_running]) == 0
+ assert len(project.containers(stopped=True)) == 3
project.remove_stopped(service_names=['web'])
- self.assertEqual(len(project.containers(stopped=True)), 1)
+ assert len(project.containers(stopped=True)) == 1
project.remove_stopped()
- self.assertEqual(len(project.containers(stopped=True)), 0)
+ assert len(project.containers(stopped=True)) == 0
def test_create(self):
web = self.create_service('web')
@@ -401,43 +394,43 @@ class ProjectTest(DockerClientTestCase):
db = self.create_service('db', volumes=[VolumeSpec.parse('/var/db')])
project = Project('composetest', [web, db], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['db'])
- self.assertEqual(len(project.containers()), 1)
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(web.containers()), 0)
+ assert len(project.containers()) == 1
+ assert len(db.containers()) == 1
+ assert len(web.containers()) == 0
def test_project_up_starts_uncreated_services(self):
db = self.create_service('db')
web = self.create_service('web', links=[(db, 'db')])
project = Project('composetest', [db, web], self.client)
project.up(['db'])
- self.assertEqual(len(project.containers()), 1)
+ assert len(project.containers()) == 1
project.up()
- self.assertEqual(len(project.containers()), 2)
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(web.containers()), 1)
+ assert len(project.containers()) == 2
+ assert len(db.containers()) == 1
+ assert len(web.containers()) == 1
def test_recreate_preserves_volumes(self):
web = self.create_service('web')
db = self.create_service('db', volumes=[VolumeSpec.parse('/etc')])
project = Project('composetest', [web, db], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['db'])
- self.assertEqual(len(project.containers()), 1)
+ assert len(project.containers()) == 1
old_db_id = project.containers()[0].id
db_volume_path = project.containers()[0].get('Volumes./etc')
project.up(strategy=ConvergenceStrategy.always)
- self.assertEqual(len(project.containers()), 2)
+ assert len(project.containers()) == 2
db_container = [c for c in project.containers() if 'db' in c.name][0]
- self.assertNotEqual(db_container.id, old_db_id)
- self.assertEqual(db_container.get('Volumes./etc'), db_volume_path)
+ assert db_container.id != old_db_id
+ assert db_container.get('Volumes./etc') == db_volume_path
@v2_3_only()
def test_recreate_preserves_mounts(self):
@@ -464,36 +457,34 @@ class ProjectTest(DockerClientTestCase):
db = self.create_service('db', volumes=[VolumeSpec.parse('/var/db')])
project = Project('composetest', [web, db], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['db'])
- self.assertEqual(len(project.containers()), 1)
+ assert len(project.containers()) == 1
old_db_id = project.containers()[0].id
container, = project.containers()
db_volume_path = container.get_mount('/var/db')['Source']
project.up(strategy=ConvergenceStrategy.never)
- self.assertEqual(len(project.containers()), 2)
+ assert len(project.containers()) == 2
db_container = [c for c in project.containers() if 'db' in c.name][0]
- self.assertEqual(db_container.id, old_db_id)
- self.assertEqual(
- db_container.get_mount('/var/db')['Source'],
- db_volume_path)
+ assert db_container.id == old_db_id
+ assert db_container.get_mount('/var/db')['Source'] == db_volume_path
def test_project_up_with_no_recreate_stopped(self):
web = self.create_service('web')
db = self.create_service('db', volumes=[VolumeSpec.parse('/var/db')])
project = Project('composetest', [web, db], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['db'])
project.kill()
old_containers = project.containers(stopped=True)
- self.assertEqual(len(old_containers), 1)
+ assert len(old_containers) == 1
old_container, = old_containers
old_db_id = old_container.id
db_volume_path = old_container.get_mount('/var/db')['Source']
@@ -501,26 +492,24 @@ class ProjectTest(DockerClientTestCase):
project.up(strategy=ConvergenceStrategy.never)
new_containers = project.containers(stopped=True)
- self.assertEqual(len(new_containers), 2)
- self.assertEqual([c.is_running for c in new_containers], [True, True])
+ assert len(new_containers) == 2
+ assert [c.is_running for c in new_containers] == [True, True]
db_container = [c for c in new_containers if 'db' in c.name][0]
- self.assertEqual(db_container.id, old_db_id)
- self.assertEqual(
- db_container.get_mount('/var/db')['Source'],
- db_volume_path)
+ assert db_container.id == old_db_id
+ assert db_container.get_mount('/var/db')['Source'] == db_volume_path
def test_project_up_without_all_services(self):
console = self.create_service('console')
db = self.create_service('db')
project = Project('composetest', [console, db], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up()
- self.assertEqual(len(project.containers()), 2)
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(console.containers()), 1)
+ assert len(project.containers()) == 2
+ assert len(db.containers()) == 1
+ assert len(console.containers()) == 1
def test_project_up_starts_links(self):
console = self.create_service('console')
@@ -529,13 +518,13 @@ class ProjectTest(DockerClientTestCase):
project = Project('composetest', [web, db, console], self.client)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['web'])
- self.assertEqual(len(project.containers()), 2)
- self.assertEqual(len(web.containers()), 1)
- self.assertEqual(len(db.containers()), 1)
- self.assertEqual(len(console.containers()), 0)
+ assert len(project.containers()) == 2
+ assert len(web.containers()) == 1
+ assert len(db.containers()) == 1
+ assert len(console.containers()) == 0
def test_project_up_starts_depends(self):
project = Project.from_config(
@@ -563,14 +552,14 @@ class ProjectTest(DockerClientTestCase):
client=self.client,
)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['web'])
- self.assertEqual(len(project.containers()), 3)
- self.assertEqual(len(project.get_service('web').containers()), 1)
- self.assertEqual(len(project.get_service('db').containers()), 1)
- self.assertEqual(len(project.get_service('data').containers()), 1)
- self.assertEqual(len(project.get_service('console').containers()), 0)
+ assert len(project.containers()) == 3
+ assert len(project.get_service('web').containers()) == 1
+ assert len(project.get_service('db').containers()) == 1
+ assert len(project.get_service('data').containers()) == 1
+ assert len(project.get_service('console').containers()) == 0
def test_project_up_with_no_deps(self):
project = Project.from_config(
@@ -598,15 +587,15 @@ class ProjectTest(DockerClientTestCase):
client=self.client,
)
project.start()
- self.assertEqual(len(project.containers()), 0)
+ assert len(project.containers()) == 0
project.up(['db'], start_deps=False)
- self.assertEqual(len(project.containers(stopped=True)), 2)
- self.assertEqual(len(project.get_service('web').containers()), 0)
- self.assertEqual(len(project.get_service('db').containers()), 1)
- self.assertEqual(len(project.get_service('data').containers(stopped=True)), 1)
+ assert len(project.containers(stopped=True)) == 2
+ assert len(project.get_service('web').containers()) == 0
+ assert len(project.get_service('db').containers()) == 1
+ assert len(project.get_service('data').containers(stopped=True)) == 1
assert not project.get_service('data').containers(stopped=True)[0].is_running
- self.assertEqual(len(project.get_service('console').containers()), 0)
+ assert len(project.get_service('console').containers()) == 0
def test_project_up_recreate_with_tmpfs_volume(self):
# https://github.com/docker/compose/issues/4751
@@ -634,22 +623,22 @@ class ProjectTest(DockerClientTestCase):
service = project.get_service('web')
service.scale(1)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
service.scale(3)
- self.assertEqual(len(service.containers()), 3)
+ assert len(service.containers()) == 3
project.up()
service = project.get_service('web')
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
service.scale(1)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
project.up(scale_override={'web': 3})
service = project.get_service('web')
- self.assertEqual(len(service.containers()), 3)
+ assert len(service.containers()) == 3
# does scale=0 ,makes any sense? after recreating at least 1 container is running
service.scale(0)
project.up()
service = project.get_service('web')
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
@v2_only()
def test_project_up_networks(self):
@@ -917,7 +906,7 @@ class ProjectTest(DockerClientTestCase):
config_data=config_data,
)
- with self.assertRaises(ProjectError):
+ with pytest.raises(ProjectError):
project.up()
@v2_1_only()
@@ -1028,7 +1017,7 @@ class ProjectTest(DockerClientTestCase):
name='composetest',
config_data=config_data
)
- with self.assertRaises(ProjectError):
+ with pytest.raises(ProjectError):
project.up()
@v2_3_only()
@@ -1068,7 +1057,7 @@ class ProjectTest(DockerClientTestCase):
name='composetest',
config_data=config_data
)
- with self.assertRaises(ProjectError):
+ with pytest.raises(ProjectError):
project.up()
@v2_3_only()
@@ -1172,11 +1161,11 @@ class ProjectTest(DockerClientTestCase):
config_data=config_data, client=self.client
)
project.up()
- self.assertEqual(len(project.containers()), 1)
+ assert len(project.containers()) == 1
volume_data = self.get_volume_data(full_vol_name)
assert volume_data['Name'].split('/')[-1] == full_vol_name
- self.assertEqual(volume_data['Driver'], 'local')
+ assert volume_data['Driver'] == 'local'
@v2_1_only()
def test_project_up_with_volume_labels(self):
@@ -1265,12 +1254,12 @@ class ProjectTest(DockerClientTestCase):
)
project.up()
containers = project.containers()
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
another = project.get_service('another').containers()[0]
log_config = another.get('HostConfig.LogConfig')
- self.assertTrue(log_config)
- self.assertEqual(log_config.get('Type'), 'none')
+ assert log_config
+ assert log_config.get('Type') == 'none'
@v2_only()
def test_project_up_port_mappings_with_multiple_files(self):
@@ -1306,7 +1295,7 @@ class ProjectTest(DockerClientTestCase):
)
project.up()
containers = project.containers()
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
@v2_2_only()
def test_project_up_config_scale(self):
@@ -1382,7 +1371,7 @@ class ProjectTest(DockerClientTestCase):
volume_data = self.get_volume_data(full_vol_name)
assert volume_data['Name'].split('/')[-1] == full_vol_name
- self.assertEqual(volume_data['Driver'], 'local')
+ assert volume_data['Driver'] == 'local'
@v3_only()
def test_project_up_with_secrets(self):
@@ -1439,7 +1428,7 @@ class ProjectTest(DockerClientTestCase):
name='composetest',
config_data=config_data, client=self.client
)
- with self.assertRaises(APIError if is_cluster(self.client) else config.ConfigurationError):
+ with pytest.raises(APIError if is_cluster(self.client) else config.ConfigurationError):
project.volumes.initialize()
@v2_only()
@@ -1465,7 +1454,7 @@ class ProjectTest(DockerClientTestCase):
volume_data = self.get_volume_data(full_vol_name)
assert volume_data['Name'].split('/')[-1] == full_vol_name
- self.assertEqual(volume_data['Driver'], 'local')
+ assert volume_data['Driver'] == 'local'
config_data = config_data._replace(
volumes={vol_name: {'driver': 'smb'}}
@@ -1475,11 +1464,11 @@ class ProjectTest(DockerClientTestCase):
config_data=config_data,
client=self.client
)
- with self.assertRaises(config.ConfigurationError) as e:
+ with pytest.raises(config.ConfigurationError) as e:
project.volumes.initialize()
assert 'Configuration for volume {0} specifies driver smb'.format(
vol_name
- ) in str(e.exception)
+ ) in str(e.value)
@v2_only()
def test_initialize_volumes_updated_blank_driver(self):
@@ -1503,7 +1492,7 @@ class ProjectTest(DockerClientTestCase):
volume_data = self.get_volume_data(full_vol_name)
assert volume_data['Name'].split('/')[-1] == full_vol_name
- self.assertEqual(volume_data['Driver'], 'local')
+ assert volume_data['Driver'] == 'local'
config_data = config_data._replace(
volumes={vol_name: {}}
@@ -1516,7 +1505,7 @@ class ProjectTest(DockerClientTestCase):
project.volumes.initialize()
volume_data = self.get_volume_data(full_vol_name)
assert volume_data['Name'].split('/')[-1] == full_vol_name
- self.assertEqual(volume_data['Driver'], 'local')
+ assert volume_data['Driver'] == 'local'
@v2_only()
@no_cluster('inspect volume by name defect on Swarm Classic')
@@ -1542,7 +1531,7 @@ class ProjectTest(DockerClientTestCase):
)
project.volumes.initialize()
- with self.assertRaises(NotFound):
+ with pytest.raises(NotFound):
self.client.inspect_volume(full_vol_name)
@v2_only()
@@ -1564,11 +1553,11 @@ class ProjectTest(DockerClientTestCase):
name='composetest',
config_data=config_data, client=self.client
)
- with self.assertRaises(config.ConfigurationError) as e:
+ with pytest.raises(config.ConfigurationError) as e:
project.volumes.initialize()
assert 'Volume {0} declared as external'.format(
vol_name
- ) in str(e.exception)
+ ) in str(e.value)
@v2_only()
def test_project_up_named_volumes_in_binds(self):
@@ -1597,10 +1586,10 @@ class ProjectTest(DockerClientTestCase):
name='composetest', config_data=config_data, client=self.client
)
service = project.services[0]
- self.assertEqual(service.name, 'simple')
+ assert service.name == 'simple'
volumes = service.options.get('volumes')
- self.assertEqual(len(volumes), 1)
- self.assertEqual(volumes[0].external, full_vol_name)
+ assert len(volumes) == 1
+ assert volumes[0].external == full_vol_name
project.up()
engine_volumes = self.client.volumes()['Volumes']
container = service.get_container()
diff --git a/tests/integration/resilience_test.py b/tests/integration/resilience_test.py
index 2a2d1b56e..3de16e977 100644
--- a/tests/integration/resilience_test.py
+++ b/tests/integration/resilience_test.py
@@ -1,6 +1,8 @@
from __future__ import absolute_import
from __future__ import unicode_literals
+import pytest
+
from .. import mock
from .testcases import DockerClientTestCase
from compose.config.types import VolumeSpec
@@ -28,25 +30,25 @@ class ResilienceTest(DockerClientTestCase):
def test_successful_recreate(self):
self.project.up(strategy=ConvergenceStrategy.always)
container = self.db.containers()[0]
- self.assertEqual(container.get_mount('/var/db')['Source'], self.host_path)
+ assert container.get_mount('/var/db')['Source'] == self.host_path
def test_create_failure(self):
with mock.patch('compose.service.Service.create_container', crash):
- with self.assertRaises(Crash):
+ with pytest.raises(Crash):
self.project.up(strategy=ConvergenceStrategy.always)
self.project.up()
container = self.db.containers()[0]
- self.assertEqual(container.get_mount('/var/db')['Source'], self.host_path)
+ assert container.get_mount('/var/db')['Source'] == self.host_path
def test_start_failure(self):
with mock.patch('compose.service.Service.start_container', crash):
- with self.assertRaises(Crash):
+ with pytest.raises(Crash):
self.project.up(strategy=ConvergenceStrategy.always)
self.project.up()
container = self.db.containers()[0]
- self.assertEqual(container.get_mount('/var/db')['Source'], self.host_path)
+ assert container.get_mount('/var/db')['Source'] == self.host_path
class Crash(Exception):
diff --git a/tests/integration/service_test.py b/tests/integration/service_test.py
index c1681a8de..7238aa69f 100644
--- a/tests/integration/service_test.py
+++ b/tests/integration/service_test.py
@@ -2,6 +2,7 @@ from __future__ import absolute_import
from __future__ import unicode_literals
import os
+import re
import shutil
import tempfile
from distutils.spawn import find_executable
@@ -62,41 +63,41 @@ class ServiceTest(DockerClientTestCase):
create_and_start_container(foo)
- self.assertEqual(len(foo.containers()), 1)
- self.assertEqual(foo.containers()[0].name, 'composetest_foo_1')
- self.assertEqual(len(bar.containers()), 0)
+ assert len(foo.containers()) == 1
+ assert foo.containers()[0].name == 'composetest_foo_1'
+ assert len(bar.containers()) == 0
create_and_start_container(bar)
create_and_start_container(bar)
- self.assertEqual(len(foo.containers()), 1)
- self.assertEqual(len(bar.containers()), 2)
+ assert len(foo.containers()) == 1
+ assert len(bar.containers()) == 2
names = [c.name for c in bar.containers()]
- self.assertIn('composetest_bar_1', names)
- self.assertIn('composetest_bar_2', names)
+ assert 'composetest_bar_1' in names
+ assert 'composetest_bar_2' in names
def test_containers_one_off(self):
db = self.create_service('db')
container = db.create_container(one_off=True)
- self.assertEqual(db.containers(stopped=True), [])
- self.assertEqual(db.containers(one_off=OneOffFilter.only, stopped=True), [container])
+ assert db.containers(stopped=True) == []
+ assert db.containers(one_off=OneOffFilter.only, stopped=True) == [container]
def test_project_is_added_to_container_name(self):
service = self.create_service('web')
create_and_start_container(service)
- self.assertEqual(service.containers()[0].name, 'composetest_web_1')
+ assert service.containers()[0].name == 'composetest_web_1'
def test_create_container_with_one_off(self):
db = self.create_service('db')
container = db.create_container(one_off=True)
- self.assertEqual(container.name, 'composetest_db_run_1')
+ assert container.name == 'composetest_db_run_1'
def test_create_container_with_one_off_when_existing_container_is_running(self):
db = self.create_service('db')
db.start()
container = db.create_container(one_off=True)
- self.assertEqual(container.name, 'composetest_db_run_1')
+ assert container.name == 'composetest_db_run_1'
def test_create_container_with_unspecified_volume(self):
service = self.create_service('db', volumes=[VolumeSpec.parse('/var/db')])
@@ -108,20 +109,20 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', volume_driver='foodriver')
container = service.create_container()
service.start_container(container)
- self.assertEqual('foodriver', container.get('HostConfig.VolumeDriver'))
+ assert 'foodriver' == container.get('HostConfig.VolumeDriver')
@pytest.mark.skipif(SWARM_SKIP_CPU_SHARES, reason='Swarm --cpu-shares bug')
def test_create_container_with_cpu_shares(self):
service = self.create_service('db', cpu_shares=73)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.CpuShares'), 73)
+ assert container.get('HostConfig.CpuShares') == 73
def test_create_container_with_cpu_quota(self):
service = self.create_service('db', cpu_quota=40000)
container = service.create_container()
container.start()
- self.assertEqual(container.get('HostConfig.CpuQuota'), 40000)
+ assert container.get('HostConfig.CpuQuota') == 40000
@v2_2_only()
def test_create_container_with_cpu_count(self):
@@ -129,7 +130,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', cpu_count=2)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.CpuCount'), 2)
+ assert container.get('HostConfig.CpuCount') == 2
@v2_2_only()
@pytest.mark.skipif(not IS_WINDOWS_PLATFORM, reason='cpu_percent is not supported for Linux')
@@ -138,7 +139,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', cpu_percent=12)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.CpuPercent'), 12)
+ assert container.get('HostConfig.CpuPercent') == 12
@v2_2_only()
def test_create_container_with_cpus(self):
@@ -146,14 +147,14 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', cpus=1)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.NanoCpus'), 1000000000)
+ assert container.get('HostConfig.NanoCpus') == 1000000000
def test_create_container_with_shm_size(self):
self.require_api_version('1.22')
service = self.create_service('db', shm_size=67108864)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.ShmSize'), 67108864)
+ assert container.get('HostConfig.ShmSize') == 67108864
def test_create_container_with_init_bool(self):
self.require_api_version('1.25')
@@ -184,7 +185,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', extra_hosts=extra_hosts)
container = service.create_container()
service.start_container(container)
- self.assertEqual(set(container.get('HostConfig.ExtraHosts')), set(extra_hosts))
+ assert set(container.get('HostConfig.ExtraHosts')) == set(extra_hosts)
def test_create_container_with_extra_hosts_dicts(self):
extra_hosts = {'somehost': '162.242.195.82', 'otherhost': '50.31.209.229'}
@@ -192,13 +193,13 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', extra_hosts=extra_hosts)
container = service.create_container()
service.start_container(container)
- self.assertEqual(set(container.get('HostConfig.ExtraHosts')), set(extra_hosts_list))
+ assert set(container.get('HostConfig.ExtraHosts')) == set(extra_hosts_list)
def test_create_container_with_cpu_set(self):
service = self.create_service('db', cpuset='0')
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.CpusetCpus'), '0')
+ assert container.get('HostConfig.CpusetCpus') == '0'
def test_create_container_with_read_only_root_fs(self):
read_only = True
@@ -240,7 +241,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', security_opt=security_opt)
container = service.create_container()
service.start_container(container)
- self.assertEqual(set(container.get('HostConfig.SecurityOpt')), set(security_opt))
+ assert set(container.get('HostConfig.SecurityOpt')) == set(security_opt)
@pytest.mark.xfail(True, reason='Not supported on most drivers')
def test_create_container_with_storage_opt(self):
@@ -248,7 +249,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', storage_opt=storage_opt)
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.get('HostConfig.StorageOpt'), storage_opt)
+ assert container.get('HostConfig.StorageOpt') == storage_opt
def test_create_container_with_oom_kill_disable(self):
self.require_api_version('1.20')
@@ -260,7 +261,7 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', mac_address='02:42:ac:11:65:43')
container = service.create_container()
service.start_container(container)
- self.assertEqual(container.inspect()['Config']['MacAddress'], '02:42:ac:11:65:43')
+ assert container.inspect()['Config']['MacAddress'] == '02:42:ac:11:65:43'
def test_create_container_with_specified_volume(self):
host_path = '/tmp/host-path'
@@ -276,8 +277,9 @@ class ServiceTest(DockerClientTestCase):
# Match the last component ("host-path"), because boot2docker symlinks /tmp
actual_host_path = container.get_mount(container_path)['Source']
- self.assertTrue(path.basename(actual_host_path) == path.basename(host_path),
- msg=("Last component differs: %s, %s" % (actual_host_path, host_path)))
+ assert path.basename(actual_host_path) == path.basename(host_path), (
+ "Last component differs: %s, %s" % (actual_host_path, host_path)
+ )
@v2_3_only()
def test_create_container_with_host_mount(self):
@@ -371,7 +373,7 @@ class ServiceTest(DockerClientTestCase):
volume_path = old_container.get_mount('/data')['Source']
new_container = service.recreate_container(old_container)
- self.assertEqual(new_container.get_mount('/data')['Source'], volume_path)
+ assert new_container.get_mount('/data')['Source'] == volume_path
def test_duplicate_volume_trailing_slash(self):
"""
@@ -393,20 +395,14 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('db', image=image, volumes=volumes)
old_container = create_and_start_container(service)
- self.assertEqual(
- old_container.get('Config.Volumes'),
- {container_path: {}},
- )
+ assert old_container.get('Config.Volumes') == {container_path: {}}
service = self.create_service('db', image=image, volumes=volumes)
new_container = service.recreate_container(old_container)
- self.assertEqual(
- new_container.get('Config.Volumes'),
- {container_path: {}},
- )
+ assert new_container.get('Config.Volumes') == {container_path: {}}
- self.assertEqual(service.containers(stopped=False), [new_container])
+ assert service.containers(stopped=False) == [new_container]
def test_create_container_with_volumes_from(self):
volume_service = self.create_service('data')
@@ -429,10 +425,8 @@ class ServiceTest(DockerClientTestCase):
)
host_container = host_service.create_container()
host_service.start_container(host_container)
- self.assertIn(volume_container_1.id + ':rw',
- host_container.get('HostConfig.VolumesFrom'))
- self.assertIn(volume_container_2.id + ':rw',
- host_container.get('HostConfig.VolumesFrom'))
+ assert volume_container_1.id + ':rw' in host_container.get('HostConfig.VolumesFrom')
+ assert volume_container_2.id + ':rw' in host_container.get('HostConfig.VolumesFrom')
def test_execute_convergence_plan_recreate(self):
service = self.create_service(
@@ -443,10 +437,10 @@ class ServiceTest(DockerClientTestCase):
command=['-d', '1']
)
old_container = service.create_container()
- self.assertEqual(old_container.get('Config.Entrypoint'), ['top'])
- self.assertEqual(old_container.get('Config.Cmd'), ['-d', '1'])
- self.assertIn('FOO=1', old_container.get('Config.Env'))
- self.assertEqual(old_container.name, 'composetest_db_1')
+ assert old_container.get('Config.Entrypoint') == ['top']
+ assert old_container.get('Config.Cmd') == ['-d', '1']
+ assert 'FOO=1' in old_container.get('Config.Env')
+ assert old_container.name == 'composetest_db_1'
service.start_container(old_container)
old_container.inspect() # reload volume data
volume_path = old_container.get_mount('/etc')['Source']
@@ -457,11 +451,11 @@ class ServiceTest(DockerClientTestCase):
new_container, = service.execute_convergence_plan(
ConvergencePlan('recreate', [old_container]))
- self.assertEqual(new_container.get('Config.Entrypoint'), ['top'])
- self.assertEqual(new_container.get('Config.Cmd'), ['-d', '1'])
- self.assertIn('FOO=2', new_container.get('Config.Env'))
- self.assertEqual(new_container.name, 'composetest_db_1')
- self.assertEqual(new_container.get_mount('/etc')['Source'], volume_path)
+ assert new_container.get('Config.Entrypoint') == ['top']
+ assert new_container.get('Config.Cmd') == ['-d', '1']
+ assert 'FOO=2' in new_container.get('Config.Env')
+ assert new_container.name == 'composetest_db_1'
+ assert new_container.get_mount('/etc')['Source'] == volume_path
if not is_cluster(self.client):
assert (
'affinity:container==%s' % old_container.id in
@@ -472,11 +466,10 @@ class ServiceTest(DockerClientTestCase):
# on the same node.
assert old_container.get('Node.Name') == new_container.get('Node.Name')
- self.assertEqual(len(self.client.containers(all=True)), num_containers_before)
- self.assertNotEqual(old_container.id, new_container.id)
- self.assertRaises(APIError,
- self.client.inspect_container,
- old_container.id)
+ assert len(self.client.containers(all=True)) == num_containers_before
+ assert old_container.id != new_container.id
+ with pytest.raises(APIError):
+ self.client.inspect_container(old_container.id)
def test_execute_convergence_plan_recreate_twice(self):
service = self.create_service(
@@ -550,17 +543,17 @@ class ServiceTest(DockerClientTestCase):
service.create_container()
containers = service.containers(stopped=True)
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
container, = containers
- self.assertFalse(container.is_running)
+ assert not container.is_running
service.execute_convergence_plan(ConvergencePlan('start', [container]))
containers = service.containers()
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
container.inspect()
- self.assertEqual(container, containers[0])
- self.assertTrue(container.is_running)
+ assert container == containers[0]
+ assert container.is_running
def test_execute_convergence_plan_with_image_declared_volume(self):
service = Service(
@@ -571,19 +564,14 @@ class ServiceTest(DockerClientTestCase):
)
old_container = create_and_start_container(service)
- self.assertEqual(
- [mount['Destination'] for mount in old_container.get('Mounts')], ['/data']
- )
+ assert [mount['Destination'] for mount in old_container.get('Mounts')] == ['/data']
volume_path = old_container.get_mount('/data')['Source']
new_container, = service.execute_convergence_plan(
ConvergencePlan('recreate', [old_container]))
- self.assertEqual(
- [mount['Destination'] for mount in new_container.get('Mounts')],
- ['/data']
- )
- self.assertEqual(new_container.get_mount('/data')['Source'], volume_path)
+ assert [mount['Destination'] for mount in new_container.get('Mounts')] == ['/data']
+ assert new_container.get_mount('/data')['Source'] == volume_path
def test_execute_convergence_plan_when_image_volume_masks_config(self):
service = self.create_service(
@@ -592,10 +580,7 @@ class ServiceTest(DockerClientTestCase):
)
old_container = create_and_start_container(service)
- self.assertEqual(
- [mount['Destination'] for mount in old_container.get('Mounts')],
- ['/data']
- )
+ assert [mount['Destination'] for mount in old_container.get('Mounts')] == ['/data']
volume_path = old_container.get_mount('/data')['Source']
service.options['volumes'] = [VolumeSpec.parse('/tmp:/data')]
@@ -606,15 +591,10 @@ class ServiceTest(DockerClientTestCase):
mock_log.warn.assert_called_once_with(mock.ANY)
_, args, kwargs = mock_log.warn.mock_calls[0]
- self.assertIn(
- "Service \"db\" is using volume \"/data\" from the previous container",
- args[0])
+ assert "Service \"db\" is using volume \"/data\" from the previous container" in args[0]
- self.assertEqual(
- [mount['Destination'] for mount in new_container.get('Mounts')],
- ['/data']
- )
- self.assertEqual(new_container.get_mount('/data')['Source'], volume_path)
+ assert [mount['Destination'] for mount in new_container.get('Mounts')] == ['/data']
+ assert new_container.get_mount('/data')['Source'] == volume_path
def test_execute_convergence_plan_when_host_volume_is_removed(self):
host_path = '/tmp/host-path'
@@ -667,12 +647,12 @@ class ServiceTest(DockerClientTestCase):
def test_start_container_passes_through_options(self):
db = self.create_service('db')
create_and_start_container(db, environment={'FOO': 'BAR'})
- self.assertEqual(db.containers()[0].environment['FOO'], 'BAR')
+ assert db.containers()[0].environment['FOO'] == 'BAR'
def test_start_container_inherits_options_from_constructor(self):
db = self.create_service('db', environment={'FOO': 'BAR'})
create_and_start_container(db)
- self.assertEqual(db.containers()[0].environment['FOO'], 'BAR')
+ assert db.containers()[0].environment['FOO'] == 'BAR'
@no_cluster('No legacy links support in Swarm')
def test_start_container_creates_links(self):
@@ -683,13 +663,11 @@ class ServiceTest(DockerClientTestCase):
create_and_start_container(db)
create_and_start_container(web)
- self.assertEqual(
- set(get_links(web.containers()[0])),
- set([
- 'composetest_db_1', 'db_1',
- 'composetest_db_2', 'db_2',
- 'db'])
- )
+ assert set(get_links(web.containers()[0])) == set([
+ 'composetest_db_1', 'db_1',
+ 'composetest_db_2', 'db_2',
+ 'db'
+ ])
@no_cluster('No legacy links support in Swarm')
def test_start_container_creates_links_with_names(self):
@@ -700,13 +678,11 @@ class ServiceTest(DockerClientTestCase):
create_and_start_container(db)
create_and_start_container(web)
- self.assertEqual(
- set(get_links(web.containers()[0])),
- set([
- 'composetest_db_1', 'db_1',
- 'composetest_db_2', 'db_2',
- 'custom_link_name'])
- )
+ assert set(get_links(web.containers()[0])) == set([
+ 'composetest_db_1', 'db_1',
+ 'composetest_db_2', 'db_2',
+ 'custom_link_name'
+ ])
@no_cluster('No legacy links support in Swarm')
def test_start_container_with_external_links(self):
@@ -719,13 +695,11 @@ class ServiceTest(DockerClientTestCase):
create_and_start_container(db)
create_and_start_container(web)
- self.assertEqual(
- set(get_links(web.containers()[0])),
- set([
- 'composetest_db_1',
- 'composetest_db_2',
- 'db_3']),
- )
+ assert set(get_links(web.containers()[0])) == set([
+ 'composetest_db_1',
+ 'composetest_db_2',
+ 'db_3'
+ ])
@no_cluster('No legacy links support in Swarm')
def test_start_normal_container_does_not_create_links_to_its_own_service(self):
@@ -735,7 +709,7 @@ class ServiceTest(DockerClientTestCase):
create_and_start_container(db)
c = create_and_start_container(db)
- self.assertEqual(set(get_links(c)), set([]))
+ assert set(get_links(c)) == set([])
@no_cluster('No legacy links support in Swarm')
def test_start_one_off_container_creates_links_to_its_own_service(self):
@@ -746,13 +720,11 @@ class ServiceTest(DockerClientTestCase):
c = create_and_start_container(db, one_off=OneOffFilter.only)
- self.assertEqual(
- set(get_links(c)),
- set([
- 'composetest_db_1', 'db_1',
- 'composetest_db_2', 'db_2',
- 'db'])
- )
+ assert set(get_links(c)) == set([
+ 'composetest_db_1', 'db_1',
+ 'composetest_db_2', 'db_2',
+ 'db'
+ ])
def test_start_container_builds_images(self):
service = Service(
@@ -763,7 +735,7 @@ class ServiceTest(DockerClientTestCase):
)
container = create_and_start_container(service)
container.wait()
- self.assertIn(b'success', container.logs())
+ assert b'success' in container.logs()
assert len(self.client.images(name='composetest_test')) >= 1
def test_start_container_uses_tagged_image_if_it_exists(self):
@@ -776,13 +748,13 @@ class ServiceTest(DockerClientTestCase):
)
container = create_and_start_container(service)
container.wait()
- self.assertIn(b'success', container.logs())
+ assert b'success' in container.logs()
def test_start_container_creates_ports(self):
service = self.create_service('web', ports=[8000])
container = create_and_start_container(service).inspect()
- self.assertEqual(list(container['NetworkSettings']['Ports'].keys()), ['8000/tcp'])
- self.assertNotEqual(container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'], '8000')
+ assert list(container['NetworkSettings']['Ports'].keys()) == ['8000/tcp']
+ assert container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'] != '8000'
def test_build(self):
base_dir = tempfile.mkdtemp()
@@ -959,34 +931,34 @@ class ServiceTest(DockerClientTestCase):
def test_start_container_stays_unprivileged(self):
service = self.create_service('web')
container = create_and_start_container(service).inspect()
- self.assertEqual(container['HostConfig']['Privileged'], False)
+ assert container['HostConfig']['Privileged'] is False
def test_start_container_becomes_privileged(self):
service = self.create_service('web', privileged=True)
container = create_and_start_container(service).inspect()
- self.assertEqual(container['HostConfig']['Privileged'], True)
+ assert container['HostConfig']['Privileged'] is True
def test_expose_does_not_publish_ports(self):
service = self.create_service('web', expose=["8000"])
container = create_and_start_container(service).inspect()
- self.assertEqual(container['NetworkSettings']['Ports'], {'8000/tcp': None})
+ assert container['NetworkSettings']['Ports'] == {'8000/tcp': None}
def test_start_container_creates_port_with_explicit_protocol(self):
service = self.create_service('web', ports=['8000/udp'])
container = create_and_start_container(service).inspect()
- self.assertEqual(list(container['NetworkSettings']['Ports'].keys()), ['8000/udp'])
+ assert list(container['NetworkSettings']['Ports'].keys()) == ['8000/udp']
def test_start_container_creates_fixed_external_ports(self):
service = self.create_service('web', ports=['8000:8000'])
container = create_and_start_container(service).inspect()
- self.assertIn('8000/tcp', container['NetworkSettings']['Ports'])
- self.assertEqual(container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'], '8000')
+ assert '8000/tcp' in container['NetworkSettings']['Ports']
+ assert container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'] == '8000'
def test_start_container_creates_fixed_external_ports_when_it_is_different_to_internal_port(self):
service = self.create_service('web', ports=['8001:8000'])
container = create_and_start_container(service).inspect()
- self.assertIn('8000/tcp', container['NetworkSettings']['Ports'])
- self.assertEqual(container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'], '8001')
+ assert '8000/tcp' in container['NetworkSettings']['Ports']
+ assert container['NetworkSettings']['Ports']['8000/tcp'][0]['HostPort'] == '8001'
def test_port_with_explicit_interface(self):
service = self.create_service('web', ports=[
@@ -1026,21 +998,21 @@ class ServiceTest(DockerClientTestCase):
def test_scale(self):
service = self.create_service('web')
service.scale(1)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
# Ensure containers don't have stdout or stdin connected
container = service.containers()[0]
config = container.inspect()['Config']
- self.assertFalse(config['AttachStderr'])
- self.assertFalse(config['AttachStdout'])
- self.assertFalse(config['AttachStdin'])
+ assert not config['AttachStderr']
+ assert not config['AttachStdout']
+ assert not config['AttachStdin']
service.scale(3)
- self.assertEqual(len(service.containers()), 3)
+ assert len(service.containers()) == 3
service.scale(1)
- self.assertEqual(len(service.containers()), 1)
+ assert len(service.containers()) == 1
service.scale(0)
- self.assertEqual(len(service.containers()), 0)
+ assert len(service.containers()) == 0
@pytest.mark.skipif(
SWARM_SKIP_CONTAINERS_ALL,
@@ -1061,12 +1033,12 @@ class ServiceTest(DockerClientTestCase):
with mock.patch('sys.stderr', new_callable=StringIO) as mock_stderr:
service.scale(2)
for container in service.containers():
- self.assertTrue(container.is_running)
- self.assertTrue(container.number in valid_numbers)
+ assert container.is_running
+ assert container.number in valid_numbers
captured_output = mock_stderr.getvalue()
- self.assertNotIn('Creating', captured_output)
- self.assertIn('Starting', captured_output)
+ assert 'Creating' not in captured_output
+ assert 'Starting' in captured_output
def test_scale_with_stopped_containers_and_needing_creation(self):
"""
@@ -1079,18 +1051,18 @@ class ServiceTest(DockerClientTestCase):
service.create_container(number=next_number, quiet=True)
for container in service.containers():
- self.assertFalse(container.is_running)
+ assert not container.is_running
with mock.patch('sys.stderr', new_callable=StringIO) as mock_stderr:
service.scale(2)
- self.assertEqual(len(service.containers()), 2)
+ assert len(service.containers()) == 2
for container in service.containers():
- self.assertTrue(container.is_running)
+ assert container.is_running
captured_output = mock_stderr.getvalue()
- self.assertIn('Creating', captured_output)
- self.assertIn('Starting', captured_output)
+ assert 'Creating' in captured_output
+ assert 'Starting' in captured_output
def test_scale_with_api_error(self):
"""Test that when scaling if the API returns an error, that error is handled
@@ -1129,11 +1101,11 @@ class ServiceTest(DockerClientTestCase):
'compose.container.Container.create',
side_effect=ValueError("BOOM")
):
- with self.assertRaises(ValueError):
+ with pytest.raises(ValueError):
service.scale(3)
- self.assertEqual(len(service.containers()), 1)
- self.assertTrue(service.containers()[0].is_running)
+ assert len(service.containers()) == 1
+ assert service.containers()[0].is_running
@mock.patch('compose.service.log')
def test_scale_with_desired_number_already_achieved(self, mock_log):
@@ -1164,28 +1136,23 @@ class ServiceTest(DockerClientTestCase):
results in warning output.
"""
service = self.create_service('app', container_name='custom-container')
- self.assertEqual(service.custom_container_name, 'custom-container')
+ assert service.custom_container_name == 'custom-container'
with pytest.raises(OperationFailedError):
service.scale(3)
captured_output = mock_log.warn.call_args[0][0]
- self.assertEqual(len(service.containers()), 1)
- self.assertIn(
- "Remove the custom name to scale the service.",
- captured_output
- )
+ assert len(service.containers()) == 1
+ assert "Remove the custom name to scale the service." in captured_output
def test_scale_sets_ports(self):
service = self.create_service('web', ports=['8000'])
service.scale(2)
containers = service.containers()
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
for container in containers:
- self.assertEqual(
- list(container.get('HostConfig.PortBindings')),
- ['8000/tcp'])
+ assert list(container.get('HostConfig.PortBindings')) == ['8000/tcp']
def test_scale_with_immediate_exit(self):
service = self.create_service('web', image='busybox', command='true')
@@ -1195,54 +1162,54 @@ class ServiceTest(DockerClientTestCase):
def test_network_mode_none(self):
service = self.create_service('web', network_mode=NetworkMode('none'))
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.NetworkMode'), 'none')
+ assert container.get('HostConfig.NetworkMode') == 'none'
def test_network_mode_bridged(self):
service = self.create_service('web', network_mode=NetworkMode('bridge'))
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.NetworkMode'), 'bridge')
+ assert container.get('HostConfig.NetworkMode') == 'bridge'
def test_network_mode_host(self):
service = self.create_service('web', network_mode=NetworkMode('host'))
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.NetworkMode'), 'host')
+ assert container.get('HostConfig.NetworkMode') == 'host'
def test_pid_mode_none_defined(self):
service = self.create_service('web', pid_mode=None)
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.PidMode'), '')
+ assert container.get('HostConfig.PidMode') == ''
def test_pid_mode_host(self):
service = self.create_service('web', pid_mode=PidMode('host'))
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.PidMode'), 'host')
+ assert container.get('HostConfig.PidMode') == 'host'
@v2_1_only()
def test_userns_mode_none_defined(self):
service = self.create_service('web', userns_mode=None)
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.UsernsMode'), '')
+ assert container.get('HostConfig.UsernsMode') == ''
@v2_1_only()
def test_userns_mode_host(self):
service = self.create_service('web', userns_mode='host')
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.UsernsMode'), 'host')
+ assert container.get('HostConfig.UsernsMode') == 'host'
def test_dns_no_value(self):
service = self.create_service('web')
container = create_and_start_container(service)
- self.assertIsNone(container.get('HostConfig.Dns'))
+ assert container.get('HostConfig.Dns') is None
def test_dns_list(self):
service = self.create_service('web', dns=['8.8.8.8', '9.9.9.9'])
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.Dns'), ['8.8.8.8', '9.9.9.9'])
+ assert container.get('HostConfig.Dns') == ['8.8.8.8', '9.9.9.9']
def test_mem_swappiness(self):
service = self.create_service('web', mem_swappiness=11)
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.MemorySwappiness'), 11)
+ assert container.get('HostConfig.MemorySwappiness') == 11
def test_mem_reservation(self):
service = self.create_service('web', mem_reservation='20m')
@@ -1252,12 +1219,12 @@ class ServiceTest(DockerClientTestCase):
def test_restart_always_value(self):
service = self.create_service('web', restart={'Name': 'always'})
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.RestartPolicy.Name'), 'always')
+ assert container.get('HostConfig.RestartPolicy.Name') == 'always'
def test_oom_score_adj_value(self):
service = self.create_service('web', oom_score_adj=500)
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.OomScoreAdj'), 500)
+ assert container.get('HostConfig.OomScoreAdj') == 500
def test_group_add_value(self):
service = self.create_service('web', group_add=["root", "1"])
@@ -1281,34 +1248,34 @@ class ServiceTest(DockerClientTestCase):
'MaximumRetryCount': 5
})
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.RestartPolicy.Name'), 'on-failure')
- self.assertEqual(container.get('HostConfig.RestartPolicy.MaximumRetryCount'), 5)
+ assert container.get('HostConfig.RestartPolicy.Name') == 'on-failure'
+ assert container.get('HostConfig.RestartPolicy.MaximumRetryCount') == 5
def test_cap_add_list(self):
service = self.create_service('web', cap_add=['SYS_ADMIN', 'NET_ADMIN'])
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.CapAdd'), ['SYS_ADMIN', 'NET_ADMIN'])
+ assert container.get('HostConfig.CapAdd') == ['SYS_ADMIN', 'NET_ADMIN']
def test_cap_drop_list(self):
service = self.create_service('web', cap_drop=['SYS_ADMIN', 'NET_ADMIN'])
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.CapDrop'), ['SYS_ADMIN', 'NET_ADMIN'])
+ assert container.get('HostConfig.CapDrop') == ['SYS_ADMIN', 'NET_ADMIN']
def test_dns_search(self):
service = self.create_service('web', dns_search=['dc1.example.com', 'dc2.example.com'])
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.DnsSearch'), ['dc1.example.com', 'dc2.example.com'])
+ assert container.get('HostConfig.DnsSearch') == ['dc1.example.com', 'dc2.example.com']
@v2_only()
def test_tmpfs(self):
service = self.create_service('web', tmpfs=['/run'])
container = create_and_start_container(service)
- self.assertEqual(container.get('HostConfig.Tmpfs'), {'/run': ''})
+ assert container.get('HostConfig.Tmpfs') == {'/run': ''}
def test_working_dir_param(self):
service = self.create_service('container', working_dir='/working/dir/sample')
container = service.create_container()
- self.assertEqual(container.get('Config.WorkingDir'), '/working/dir/sample')
+ assert container.get('Config.WorkingDir') == '/working/dir/sample'
def test_split_env(self):
service = self.create_service(
@@ -1316,7 +1283,7 @@ class ServiceTest(DockerClientTestCase):
environment=['NORMAL=F1', 'CONTAINS_EQUALS=F=2', 'TRAILING_EQUALS='])
env = create_and_start_container(service).environment
for k, v in {'NORMAL': 'F1', 'CONTAINS_EQUALS': 'F=2', 'TRAILING_EQUALS': ''}.items():
- self.assertEqual(env[k], v)
+ assert env[k] == v
def test_env_from_file_combined_with_env(self):
service = self.create_service(
@@ -1331,7 +1298,7 @@ class ServiceTest(DockerClientTestCase):
'FOO': 'baz',
'DOO': 'dah'
}.items():
- self.assertEqual(env[k], v)
+ assert env[k] == v
@v3_only()
def test_build_with_cachefrom(self):
@@ -1370,14 +1337,14 @@ class ServiceTest(DockerClientTestCase):
'ENV_DEF': 'E3',
'NO_DEF': None
}.items():
- self.assertEqual(env[k], v)
+ assert env[k] == v
def test_with_high_enough_api_version_we_get_default_network_mode(self):
# TODO: remove this test once minimum docker version is 1.8.x
with mock.patch.object(self.client, '_version', '1.20'):
service = self.create_service('web')
service_config = service._get_container_host_config({})
- self.assertEqual(service_config['NetworkMode'], 'default')
+ assert service_config['NetworkMode'] == 'default'
def test_labels(self):
labels_dict = {
@@ -1398,52 +1365,53 @@ class ServiceTest(DockerClientTestCase):
service = self.create_service('web', labels=labels_dict)
labels = create_and_start_container(service).labels.items()
for pair in expected.items():
- self.assertIn(pair, labels)
+ assert pair in labels
def test_empty_labels(self):
labels_dict = {'foo': '', 'bar': ''}
service = self.create_service('web', labels=labels_dict)
labels = create_and_start_container(service).labels.items()
for name in labels_dict:
- self.assertIn((name, ''), labels)
+ assert (name, '') in labels
def test_stop_signal(self):
stop_signal = 'SIGINT'
service = self.create_service('web', stop_signal=stop_signal)
container = create_and_start_container(service)
- self.assertEqual(container.stop_signal, stop_signal)
+ assert container.stop_signal == stop_signal
def test_custom_container_name(self):
service = self.create_service('web', container_name='my-web-container')
- self.assertEqual(service.custom_container_name, 'my-web-container')
+ assert service.custom_container_name == 'my-web-container'
container = create_and_start_container(service)
- self.assertEqual(container.name, 'my-web-container')
+ assert container.name == 'my-web-container'
one_off_container = service.create_container(one_off=True)
- self.assertNotEqual(one_off_container.name, 'my-web-container')
+ assert one_off_container.name != 'my-web-container'
@pytest.mark.skipif(True, reason="Broken on 1.11.0 - 17.03.0")
def test_log_drive_invalid(self):
service = self.create_service('web', logging={'driver': 'xxx'})
expected_error_msg = "logger: no log driver named 'xxx' is registered"
- with self.assertRaisesRegexp(APIError, expected_error_msg):
+ with pytest.raises(APIError) as excinfo:
create_and_start_container(service)
+ assert re.search(expected_error_msg, excinfo.value)
def test_log_drive_empty_default_jsonfile(self):
service = self.create_service('web')
log_config = create_and_start_container(service).log_config
- self.assertEqual('json-file', log_config['Type'])
- self.assertFalse(log_config['Config'])
+ assert 'json-file' == log_config['Type']
+ assert not log_config['Config']
def test_log_drive_none(self):
service = self.create_service('web', logging={'driver': 'none'})
log_config = create_and_start_container(service).log_config
- self.assertEqual('none', log_config['Type'])
- self.assertFalse(log_config['Config'])
+ assert 'none' == log_config['Type']
+ assert not log_config['Config']
def test_devices(self):
service = self.create_service('web', devices=["/dev/random:/dev/mapped-random"])
@@ -1455,8 +1423,8 @@ class ServiceTest(DockerClientTestCase):
'PathInContainer': '/dev/mapped-random'
}
- self.assertEqual(1, len(device_config))
- self.assertDictEqual(device_dict, device_config[0])
+ assert 1 == len(device_config)
+ assert device_dict == device_config[0]
def test_duplicate_containers(self):
service = self.create_service('web')
@@ -1464,14 +1432,14 @@ class ServiceTest(DockerClientTestCase):
options = service._get_container_create_options({}, 1)
original = Container.create(service.client, **options)
- self.assertEqual(set(service.containers(stopped=True)), set([original]))
- self.assertEqual(set(service.duplicate_containers()), set())
+ assert set(service.containers(stopped=True)) == set([original])
+ assert set(service.duplicate_containers()) == set()
options['name'] = 'temporary_container_name'
duplicate = Container.create(service.client, **options)
- self.assertEqual(set(service.containers(stopped=True)), set([original, duplicate]))
- self.assertEqual(set(service.duplicate_containers()), set([duplicate]))
+ assert set(service.containers(stopped=True)) == set([original, duplicate])
+ assert set(service.duplicate_containers()) == set([duplicate])
def converge(service, strategy=ConvergenceStrategy.changed):
@@ -1485,24 +1453,24 @@ class ConfigHashTest(DockerClientTestCase):
def test_no_config_hash_when_one_off(self):
web = self.create_service('web')
container = web.create_container(one_off=True)
- self.assertNotIn(LABEL_CONFIG_HASH, container.labels)
+ assert LABEL_CONFIG_HASH not in container.labels
def test_no_config_hash_when_overriding_options(self):
web = self.create_service('web')
container = web.create_container(environment={'FOO': '1'})
- self.assertNotIn(LABEL_CONFIG_HASH, container.labels)
+ assert LABEL_CONFIG_HASH not in container.labels
def test_config_hash_with_custom_labels(self):
web = self.create_service('web', labels={'foo': '1'})
container = converge(web)[0]
- self.assertIn(LABEL_CONFIG_HASH, container.labels)
- self.assertIn('foo', container.labels)
+ assert LABEL_CONFIG_HASH in container.labels
+ assert 'foo' in container.labels
def test_config_hash_sticks_around(self):
web = self.create_service('web', command=["top"])
container = converge(web)[0]
- self.assertIn(LABEL_CONFIG_HASH, container.labels)
+ assert LABEL_CONFIG_HASH in container.labels
web = self.create_service('web', command=["top", "-d", "1"])
container = converge(web)[0]
- self.assertIn(LABEL_CONFIG_HASH, container.labels)
+ assert LABEL_CONFIG_HASH in container.labels
diff --git a/tests/integration/state_test.py b/tests/integration/state_test.py
index 047dc7046..0b174f69f 100644
--- a/tests/integration/state_test.py
+++ b/tests/integration/state_test.py
@@ -46,12 +46,12 @@ class BasicProjectTest(ProjectTestCase):
def test_no_change(self):
old_containers = self.run_up(self.cfg)
- self.assertEqual(len(old_containers), 2)
+ assert len(old_containers) == 2
new_containers = self.run_up(self.cfg)
- self.assertEqual(len(new_containers), 2)
+ assert len(new_containers) == 2
- self.assertEqual(old_containers, new_containers)
+ assert old_containers == new_containers
def test_partial_change(self):
old_containers = self.run_up(self.cfg)
@@ -61,34 +61,34 @@ class BasicProjectTest(ProjectTestCase):
self.cfg['web']['command'] = '/bin/true'
new_containers = self.run_up(self.cfg)
- self.assertEqual(len(new_containers), 2)
+ assert len(new_containers) == 2
preserved = list(old_containers & new_containers)
- self.assertEqual(preserved, [old_db])
+ assert preserved == [old_db]
removed = list(old_containers - new_containers)
- self.assertEqual(removed, [old_web])
+ assert removed == [old_web]
created = list(new_containers - old_containers)
- self.assertEqual(len(created), 1)
- self.assertEqual(created[0].name_without_project, 'web_1')
- self.assertEqual(created[0].get('Config.Cmd'), ['/bin/true'])
+ assert len(created) == 1
+ assert created[0].name_without_project == 'web_1'
+ assert created[0].get('Config.Cmd') == ['/bin/true']
def test_all_change(self):
old_containers = self.run_up(self.cfg)
- self.assertEqual(len(old_containers), 2)
+ assert len(old_containers) == 2
self.cfg['web']['command'] = '/bin/true'
self.cfg['db']['command'] = '/bin/true'
new_containers = self.run_up(self.cfg)
- self.assertEqual(len(new_containers), 2)
+ assert len(new_containers) == 2
unchanged = old_containers & new_containers
- self.assertEqual(len(unchanged), 0)
+ assert len(unchanged) == 0
new = new_containers - old_containers
- self.assertEqual(len(new), 2)
+ assert len(new) == 2
class ProjectWithDependenciesTest(ProjectTestCase):
@@ -114,10 +114,7 @@ class ProjectWithDependenciesTest(ProjectTestCase):
def test_up(self):
containers = self.run_up(self.cfg)
- self.assertEqual(
- set(c.name_without_project for c in containers),
- set(['db_1', 'web_1', 'nginx_1']),
- )
+ assert set(c.name_without_project for c in containers) == set(['db_1', 'web_1', 'nginx_1'])
def test_change_leaf(self):
old_containers = self.run_up(self.cfg)
@@ -125,10 +122,7 @@ class ProjectWithDependenciesTest(ProjectTestCase):
self.cfg['nginx']['environment'] = {'NEW_VAR': '1'}
new_containers = self.run_up(self.cfg)
- self.assertEqual(
- set(c.name_without_project for c in new_containers - old_containers),
- set(['nginx_1']),
- )
+ assert set(c.name_without_project for c in new_containers - old_containers) == set(['nginx_1'])
def test_change_middle(self):
old_containers = self.run_up(self.cfg)
@@ -136,9 +130,8 @@ class ProjectWithDependenciesTest(ProjectTestCase):
self.cfg['web']['environment'] = {'NEW_VAR': '1'}
new_containers = self.run_up(self.cfg)
- self.assertEqual(
- set(c.name_without_project for c in new_containers - old_containers),
- set(['web_1', 'nginx_1']),
+ assert set(c.name_without_project for c in new_containers - old_containers) == set(
+ ['web_1', 'nginx_1']
)
def test_change_root(self):
@@ -147,9 +140,8 @@ class ProjectWithDependenciesTest(ProjectTestCase):
self.cfg['db']['environment'] = {'NEW_VAR': '1'}
new_containers = self.run_up(self.cfg)
- self.assertEqual(
- set(c.name_without_project for c in new_containers - old_containers),
- set(['db_1', 'web_1', 'nginx_1']),
+ assert set(c.name_without_project for c in new_containers - old_containers) == set(
+ ['db_1', 'web_1', 'nginx_1']
)
def test_change_root_no_recreate(self):
@@ -160,7 +152,7 @@ class ProjectWithDependenciesTest(ProjectTestCase):
self.cfg,
strategy=ConvergenceStrategy.never)
- self.assertEqual(new_containers - old_containers, set())
+ assert new_containers - old_containers == set()
def test_service_removed_while_down(self):
next_cfg = {
@@ -172,26 +164,26 @@ class ProjectWithDependenciesTest(ProjectTestCase):
}
containers = self.run_up(self.cfg)
- self.assertEqual(len(containers), 3)
+ assert len(containers) == 3
project = self.make_project(self.cfg)
project.stop(timeout=1)
containers = self.run_up(next_cfg)
- self.assertEqual(len(containers), 2)
+ assert len(containers) == 2
def test_service_recreated_when_dependency_created(self):
containers = self.run_up(self.cfg, service_names=['web'], start_deps=False)
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
containers = self.run_up(self.cfg)
- self.assertEqual(len(containers), 3)
+ assert len(containers) == 3
web, = [c for c in containers if c.service == 'web']
nginx, = [c for c in containers if c.service == 'nginx']
- self.assertEqual(set(get_links(web)), {'composetest_db_1', 'db', 'db_1'})
- self.assertEqual(set(get_links(nginx)), {'composetest_web_1', 'web', 'web_1'})
+ assert set(get_links(web)) == {'composetest_db_1', 'db', 'db_1'}
+ assert set(get_links(nginx)) == {'composetest_web_1', 'web', 'web_1'}
class ServiceStateTest(DockerClientTestCase):
@@ -199,7 +191,7 @@ class ServiceStateTest(DockerClientTestCase):
def test_trigger_create(self):
web = self.create_service('web')
- self.assertEqual(('create', []), web.convergence_plan())
+ assert ('create', []) == web.convergence_plan()
def test_trigger_noop(self):
web = self.create_service('web')
@@ -207,7 +199,7 @@ class ServiceStateTest(DockerClientTestCase):
web.start()
web = self.create_service('web')
- self.assertEqual(('noop', [container]), web.convergence_plan())
+ assert ('noop', [container]) == web.convergence_plan()
def test_trigger_start(self):
options = dict(command=["top"])
@@ -219,26 +211,23 @@ class ServiceStateTest(DockerClientTestCase):
containers[0].stop()
containers[0].inspect()
- self.assertEqual([c.is_running for c in containers], [False, True])
+ assert [c.is_running for c in containers] == [False, True]
- self.assertEqual(
- ('start', containers[0:1]),
- web.convergence_plan(),
- )
+ assert ('start', containers[0:1]) == web.convergence_plan()
def test_trigger_recreate_with_config_change(self):
web = self.create_service('web', command=["top"])
container = web.create_container()
web = self.create_service('web', command=["top", "-d", "1"])
- self.assertEqual(('recreate', [container]), web.convergence_plan())
+ assert ('recreate', [container]) == web.convergence_plan()
def test_trigger_recreate_with_nonexistent_image_tag(self):
web = self.create_service('web', image="busybox:latest")
container = web.create_container()
web = self.create_service('web', image="nonexistent-image")
- self.assertEqual(('recreate', [container]), web.convergence_plan())
+ assert ('recreate', [container]) == web.convergence_plan()
def test_trigger_recreate_with_image_change(self):
repo = 'composetest_myimage'
@@ -270,7 +259,7 @@ class ServiceStateTest(DockerClientTestCase):
self.client.remove_container(c)
web = self.create_service('web', image=image)
- self.assertEqual(('recreate', [container]), web.convergence_plan())
+ assert ('recreate', [container]) == web.convergence_plan()
@no_cluster('Can not guarantee the build will be run on the same node the service is deployed')
def test_trigger_recreate_with_build(self):
@@ -288,7 +277,7 @@ class ServiceStateTest(DockerClientTestCase):
web.build()
web = self.create_service('web', build={'context': str(context)})
- self.assertEqual(('recreate', [container]), web.convergence_plan())
+ assert ('recreate', [container]) == web.convergence_plan()
def test_image_changed_to_build(self):
context = py.test.ensuretemp('test_image_changed_to_build')
@@ -303,6 +292,6 @@ class ServiceStateTest(DockerClientTestCase):
web = self.create_service('web', build={'context': str(context)})
plan = web.convergence_plan()
- self.assertEqual(('recreate', [container]), plan)
+ assert ('recreate', [container]) == plan
containers = web.execute_convergence_plan(plan)
- self.assertEqual(len(containers), 1)
+ assert len(containers) == 1
diff --git a/tests/unit/cli/docker_client_test.py b/tests/unit/cli/docker_client_test.py
index 482ad9850..c4cd275f3 100644
--- a/tests/unit/cli/docker_client_test.py
+++ b/tests/unit/cli/docker_client_test.py
@@ -60,7 +60,7 @@ class DockerClientTestCase(unittest.TestCase):
platform.system(),
platform.release()
)
- self.assertEqual(client.headers['User-Agent'], expected)
+ assert client.headers['User-Agent'] == expected
class TLSConfigTestCase(unittest.TestCase):
diff --git a/tests/unit/cli/verbose_proxy_test.py b/tests/unit/cli/verbose_proxy_test.py
index f77568dc0..f111f8cdb 100644
--- a/tests/unit/cli/verbose_proxy_test.py
+++ b/tests/unit/cli/verbose_proxy_test.py
@@ -16,18 +16,18 @@ class VerboseProxyTestCase(unittest.TestCase):
("arg1", True),
{'key': 'value'})
- self.assertEqual(expected, actual)
+ assert expected == actual
def test_format_return_sequence(self):
expected = "(list with 10 items)"
actual = verbose_proxy.format_return(list(range(10)), 2)
- self.assertEqual(expected, actual)
+ assert expected == actual
def test_format_return(self):
expected = repr({'Id': 'ok'})
actual = verbose_proxy.format_return({'Id': 'ok'}, 2)
- self.assertEqual(expected, actual)
+ assert expected == actual
def test_format_return_no_result(self):
actual = verbose_proxy.format_return(None, 2)
- self.assertEqual(None, actual)
+ assert actual is None
diff --git a/tests/unit/cli_test.py b/tests/unit/cli_test.py
index c6aa75b26..19f6c9782 100644
--- a/tests/unit/cli_test.py
+++ b/tests/unit/cli_test.py
@@ -30,36 +30,36 @@ class CLITestCase(unittest.TestCase):
test_dir = py._path.local.LocalPath('tests/fixtures/simple-composefile')
with test_dir.as_cwd():
project_name = get_project_name('.')
- self.assertEqual('simplecomposefile', project_name)
+ assert 'simplecomposefile' == project_name
def test_project_name_with_explicit_base_dir(self):
base_dir = 'tests/fixtures/simple-composefile'
project_name = get_project_name(base_dir)
- self.assertEqual('simplecomposefile', project_name)
+ assert 'simplecomposefile' == project_name
def test_project_name_with_explicit_uppercase_base_dir(self):
base_dir = 'tests/fixtures/UpperCaseDir'
project_name = get_project_name(base_dir)
- self.assertEqual('uppercasedir', project_name)
+ assert 'uppercasedir' == project_name
def test_project_name_with_explicit_project_name(self):
name = 'explicit-project-name'
project_name = get_project_name(None, project_name=name)
- self.assertEqual('explicitprojectname', project_name)
+ assert 'explicitprojectname' == project_name
@mock.patch.dict(os.environ)
def test_project_name_from_environment_new_var(self):
name = 'namefromenv'
os.environ['COMPOSE_PROJECT_NAME'] = name
project_name = get_project_name(None)
- self.assertEqual(project_name, name)
+ assert project_name == name
def test_project_name_with_empty_environment_var(self):
base_dir = 'tests/fixtures/simple-composefile'
with mock.patch.dict(os.environ):
os.environ['COMPOSE_PROJECT_NAME'] = ''
project_name = get_project_name(base_dir)
- self.assertEqual('simplecomposefile', project_name)
+ assert 'simplecomposefile' == project_name
@mock.patch.dict(os.environ)
def test_project_name_with_environment_file(self):
@@ -80,9 +80,9 @@ class CLITestCase(unittest.TestCase):
def test_get_project(self):
base_dir = 'tests/fixtures/longer-filename-composefile'
project = get_project(base_dir)
- self.assertEqual(project.name, 'longerfilenamecomposefile')
- self.assertTrue(project.client)
- self.assertTrue(project.services)
+ assert project.name == 'longerfilenamecomposefile'
+ assert project.client
+ assert project.services
def test_command_help(self):
with mock.patch('sys.stdout', new=StringIO()) as fake_stdout:
@@ -165,10 +165,7 @@ class CLITestCase(unittest.TestCase):
'--workdir': None,
})
- self.assertEqual(
- mock_client.create_host_config.call_args[1]['restart_policy']['Name'],
- 'always'
- )
+ assert mock_client.create_host_config.call_args[1]['restart_policy']['Name'] == 'always'
command = TopLevelCommand(project)
command.run({
@@ -189,9 +186,7 @@ class CLITestCase(unittest.TestCase):
'--workdir': None,
})
- self.assertFalse(
- mock_client.create_host_config.call_args[1].get('restart_policy')
- )
+ assert not mock_client.create_host_config.call_args[1].get('restart_policy')
def test_command_manual_and_service_ports_together(self):
project = Project.from_config(
@@ -203,7 +198,7 @@ class CLITestCase(unittest.TestCase):
)
command = TopLevelCommand(project)
- with self.assertRaises(UserError):
+ with pytest.raises(UserError):
command.run({
'SERVICE': 'service',
'COMMAND': None,
diff --git a/tests/unit/config/config_test.py b/tests/unit/config/config_test.py
index 22f98ec55..03626ad36 100644
--- a/tests/unit/config/config_test.py
+++ b/tests/unit/config/config_test.py
@@ -77,20 +77,17 @@ class ConfigTest(unittest.TestCase):
)
).services
- self.assertEqual(
- service_sort(service_dicts),
- service_sort([
- {
- 'name': 'bar',
- 'image': 'busybox',
- 'environment': {'FOO': '1'},
- },
- {
- 'name': 'foo',
- 'image': 'busybox',
- }
- ])
- )
+ assert service_sort(service_dicts) == service_sort([
+ {
+ 'name': 'bar',
+ 'image': 'busybox',
+ 'environment': {'FOO': '1'},
+ },
+ {
+ 'name': 'foo',
+ 'image': 'busybox',
+ }
+ ])
def test_load_v2(self):
config_data = config.load(
@@ -129,27 +126,24 @@ class ConfigTest(unittest.TestCase):
service_dicts = config_data.services
volume_dict = config_data.volumes
networks_dict = config_data.networks
- self.assertEqual(
- service_sort(service_dicts),
- service_sort([
- {
- 'name': 'bar',
- 'image': 'busybox',
- 'environment': {'FOO': '1'},
- },
- {
- 'name': 'foo',
- 'image': 'busybox',
- }
- ])
- )
- self.assertEqual(volume_dict, {
+ assert service_sort(service_dicts) == service_sort([
+ {
+ 'name': 'bar',
+ 'image': 'busybox',
+ 'environment': {'FOO': '1'},
+ },
+ {
+ 'name': 'foo',
+ 'image': 'busybox',
+ }
+ ])
+ assert volume_dict == {
'hello': {
'driver': 'default',
'driver_opts': {'beep': 'boop'}
}
- })
- self.assertEqual(networks_dict, {
+ }
+ assert networks_dict == {
'default': {
'driver': 'bridge',
'driver_opts': {'beep': 'boop'}
@@ -166,7 +160,7 @@ class ConfigTest(unittest.TestCase):
'driver': 'bridge',
'internal': True
}
- })
+ }
def test_valid_versions(self):
for version in ['2', '2.0']:
@@ -335,18 +329,15 @@ class ConfigTest(unittest.TestCase):
in mock_logging.warn.call_args[0][0]
service_dicts = config_data.services
- self.assertEqual(
- service_sort(service_dicts),
- service_sort([
- {
- 'name': 'version',
- 'image': 'busybox',
- }
- ])
- )
+ assert service_sort(service_dicts) == service_sort([
+ {
+ 'name': 'version',
+ 'image': 'busybox',
+ }
+ ])
def test_load_throws_error_when_not_dict(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details(
{'web': 'busybox:latest'},
@@ -356,7 +347,7 @@ class ConfigTest(unittest.TestCase):
)
def test_load_throws_error_when_not_dict_v2(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details(
{'version': '2', 'services': {'web': 'busybox:latest'}},
@@ -366,7 +357,7 @@ class ConfigTest(unittest.TestCase):
)
def test_load_throws_error_with_invalid_network_fields(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details({
'version': '2',
@@ -766,7 +757,7 @@ class ConfigTest(unittest.TestCase):
'labels': {'label': 'one'},
},
]
- self.assertEqual(service_sort(service_dicts), service_sort(expected))
+ assert service_sort(service_dicts) == service_sort(expected)
def test_load_mixed_extends_resolution(self):
main_file = config.ConfigFile(
@@ -862,12 +853,12 @@ class ConfigTest(unittest.TestCase):
'filename.yml'
)
).services
- self.assertTrue('context' in service[0]['build'])
- self.assertEqual(service[0]['build']['dockerfile'], 'Dockerfile-alt')
+ assert 'context' in service[0]['build']
+ assert service[0]['build']['dockerfile'] == 'Dockerfile-alt'
def test_config_build_configuration_v2(self):
# service.dockerfile is invalid in v2
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details(
{
@@ -894,7 +885,7 @@ class ConfigTest(unittest.TestCase):
}
}, 'tests/fixtures/extends', 'filename.yml')
).services[0]
- self.assertTrue('context' in service['build'])
+ assert 'context' in service['build']
service = config.load(
build_config_details(
@@ -913,8 +904,8 @@ class ConfigTest(unittest.TestCase):
'filename.yml'
)
).services
- self.assertTrue('context' in service[0]['build'])
- self.assertEqual(service[0]['build']['dockerfile'], 'Dockerfile-alt')
+ assert 'context' in service[0]['build']
+ assert service[0]['build']['dockerfile'] == 'Dockerfile-alt'
def test_load_with_buildargs(self):
service = config.load(
@@ -1226,7 +1217,7 @@ class ConfigTest(unittest.TestCase):
}
)
details = config.ConfigDetails('.', [base_file])
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(details)
base_file = config.ConfigFile(
@@ -1575,7 +1566,7 @@ class ConfigTest(unittest.TestCase):
'filename.yml'
)
).services
- self.assertEqual(service[0]['expose'], expose)
+ assert service[0]['expose'] == expose
def test_valid_config_oneof_string_or_list(self):
entrypoint_values = [["sh"], "sh"]
@@ -1590,7 +1581,7 @@ class ConfigTest(unittest.TestCase):
'filename.yml'
)
).services
- self.assertEqual(service[0]['entrypoint'], entrypoint)
+ assert service[0]['entrypoint'] == entrypoint
def test_logs_warning_for_boolean_in_environment(self):
config_details = build_config_details({
@@ -1616,7 +1607,7 @@ class ConfigTest(unittest.TestCase):
'filename.yml'
)
).services
- self.assertEqual(services[0]['environment']['SPRING_JPA_HIBERNATE_DDL-AUTO'], 'none')
+ assert services[0]['environment']['SPRING_JPA_HIBERNATE_DDL-AUTO'] == 'none'
def test_load_yaml_with_yaml_error(self):
tmpdir = py.test.ensuretemp('invalid_yaml_test')
@@ -2208,7 +2199,7 @@ class ConfigTest(unittest.TestCase):
None,
)
).services[0]
- self.assertEqual(service_dict['environment']['POSTGRES_PASSWORD'], '')
+ assert service_dict['environment']['POSTGRES_PASSWORD'] == ''
def test_merge_pid(self):
# Regression: https://github.com/docker/compose/issues/4184
@@ -2565,7 +2556,7 @@ class ConfigTest(unittest.TestCase):
assert "Service 'one' depends on service 'three'" in exc.exconly()
def test_linked_service_is_undefined(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details({
'version': '2',
@@ -3097,7 +3088,7 @@ class InterpolationTest(unittest.TestCase):
)
).services
- self.assertEqual(service_dicts[0], {
+ assert service_dicts[0] == {
'name': 'web',
'image': 'alpine:latest',
'ports': [
@@ -3105,7 +3096,7 @@ class InterpolationTest(unittest.TestCase):
types.ServicePort.parse('9999')[0]
],
'command': 'true'
- })
+ }
@mock.patch.dict(os.environ)
def test_config_file_with_environment_variable(self):
@@ -3122,7 +3113,7 @@ class InterpolationTest(unittest.TestCase):
)
).services
- self.assertEqual(service_dicts, [
+ assert service_dicts == [
{
'name': 'web',
'image': 'busybox',
@@ -3131,7 +3122,7 @@ class InterpolationTest(unittest.TestCase):
'hostname': 'host-',
'command': '${ESCAPED}',
}
- ])
+ ]
@mock.patch.dict(os.environ)
def test_config_file_with_environment_variable_with_defaults(self):
@@ -3146,14 +3137,14 @@ class InterpolationTest(unittest.TestCase):
)
).services
- self.assertEqual(service_dicts, [
+ assert service_dicts == [
{
'name': 'web',
'image': 'busybox',
'ports': types.ServicePort.parse('80:8000'),
'hostname': 'host-',
}
- ])
+ ]
@mock.patch.dict(os.environ)
def test_unset_variable_produces_warning(self):
@@ -3174,14 +3165,14 @@ class InterpolationTest(unittest.TestCase):
with mock.patch('compose.config.environment.log') as log:
config.load(config_details)
- self.assertEqual(2, log.warn.call_count)
+ assert 2 == log.warn.call_count
warnings = sorted(args[0][0] for args in log.warn.call_args_list)
- self.assertIn('BAR', warnings[0])
- self.assertIn('FOO', warnings[1])
+ assert 'BAR' in warnings[0]
+ assert 'FOO' in warnings[1]
@mock.patch.dict(os.environ)
def test_invalid_interpolation(self):
- with self.assertRaises(config.ConfigurationError) as cm:
+ with pytest.raises(config.ConfigurationError) as cm:
config.load(
build_config_details(
{'web': {'image': '${'}},
@@ -3190,10 +3181,10 @@ class InterpolationTest(unittest.TestCase):
)
)
- self.assertIn('Invalid', cm.exception.msg)
- self.assertIn('for "image" option', cm.exception.msg)
- self.assertIn('in service "web"', cm.exception.msg)
- self.assertIn('"${"', cm.exception.msg)
+ assert 'Invalid' in cm.value.msg
+ assert 'for "image" option' in cm.value.msg
+ assert 'in service "web"' in cm.value.msg
+ assert '"${"' in cm.value.msg
@mock.patch.dict(os.environ)
def test_interpolation_secrets_section(self):
@@ -3236,7 +3227,7 @@ class VolumeConfigTest(unittest.TestCase):
def test_no_binding(self):
d = make_service_dict('foo', {'build': '.', 'volumes': ['/data']}, working_dir='.')
- self.assertEqual(d['volumes'], ['/data'])
+ assert d['volumes'] == ['/data']
@mock.patch.dict(os.environ)
def test_volume_binding_with_environment_variable(self):
@@ -3249,26 +3240,26 @@ class VolumeConfigTest(unittest.TestCase):
None,
)
).services[0]
- self.assertEqual(d['volumes'], [VolumeSpec.parse('/host/path:/container/path')])
+ assert d['volumes'] == [VolumeSpec.parse('/host/path:/container/path')]
@pytest.mark.skipif(IS_WINDOWS_PLATFORM, reason='posix paths')
@mock.patch.dict(os.environ)
def test_volume_binding_with_home(self):
os.environ['HOME'] = '/home/user'
d = make_service_dict('foo', {'build': '.', 'volumes': ['~:/container/path']}, working_dir='.')
- self.assertEqual(d['volumes'], ['/home/user:/container/path'])
+ assert d['volumes'] == ['/home/user:/container/path']
def test_name_does_not_expand(self):
d = make_service_dict('foo', {'build': '.', 'volumes': ['mydatavolume:/data']}, working_dir='.')
- self.assertEqual(d['volumes'], ['mydatavolume:/data'])
+ assert d['volumes'] == ['mydatavolume:/data']
def test_absolute_posix_path_does_not_expand(self):
d = make_service_dict('foo', {'build': '.', 'volumes': ['/var/lib/data:/data']}, working_dir='.')
- self.assertEqual(d['volumes'], ['/var/lib/data:/data'])
+ assert d['volumes'] == ['/var/lib/data:/data']
def test_absolute_windows_path_does_not_expand(self):
d = make_service_dict('foo', {'build': '.', 'volumes': ['c:\\data:/data']}, working_dir='.')
- self.assertEqual(d['volumes'], ['c:\\data:/data'])
+ assert d['volumes'] == ['c:\\data:/data']
@pytest.mark.skipif(IS_WINDOWS_PLATFORM, reason='posix paths')
def test_relative_path_does_expand_posix(self):
@@ -3276,19 +3267,19 @@ class VolumeConfigTest(unittest.TestCase):
'foo',
{'build': '.', 'volumes': ['./data:/data']},
working_dir='/home/me/myproject')
- self.assertEqual(d['volumes'], ['/home/me/myproject/data:/data'])
+ assert d['volumes'] == ['/home/me/myproject/data:/data']
d = make_service_dict(
'foo',
{'build': '.', 'volumes': ['.:/data']},
working_dir='/home/me/myproject')
- self.assertEqual(d['volumes'], ['/home/me/myproject:/data'])
+ assert d['volumes'] == ['/home/me/myproject:/data']
d = make_service_dict(
'foo',
{'build': '.', 'volumes': ['../otherproject:/data']},
working_dir='/home/me/myproject')
- self.assertEqual(d['volumes'], ['/home/me/otherproject:/data'])
+ assert d['volumes'] == ['/home/me/otherproject:/data']
@pytest.mark.skipif(not IS_WINDOWS_PLATFORM, reason='windows paths')
def test_relative_path_does_expand_windows(self):
@@ -3296,19 +3287,19 @@ class VolumeConfigTest(unittest.TestCase):
'foo',
{'build': '.', 'volumes': ['./data:/data']},
working_dir='c:\\Users\\me\\myproject')
- self.assertEqual(d['volumes'], ['c:\\Users\\me\\myproject\\data:/data'])
+ assert d['volumes'] == ['c:\\Users\\me\\myproject\\data:/data']
d = make_service_dict(
'foo',
{'build': '.', 'volumes': ['.:/data']},
working_dir='c:\\Users\\me\\myproject')
- self.assertEqual(d['volumes'], ['c:\\Users\\me\\myproject:/data'])
+ assert d['volumes'] == ['c:\\Users\\me\\myproject:/data']
d = make_service_dict(
'foo',
{'build': '.', 'volumes': ['../otherproject:/data']},
working_dir='c:\\Users\\me\\myproject')
- self.assertEqual(d['volumes'], ['c:\\Users\\me\\otherproject:/data'])
+ assert d['volumes'] == ['c:\\Users\\me\\otherproject:/data']
@mock.patch.dict(os.environ)
def test_home_directory_with_driver_does_not_expand(self):
@@ -3318,12 +3309,12 @@ class VolumeConfigTest(unittest.TestCase):
'volumes': ['~:/data'],
'volume_driver': 'foodriver',
}, working_dir='.')
- self.assertEqual(d['volumes'], ['~:/data'])
+ assert d['volumes'] == ['~:/data']
def test_volume_path_with_non_ascii_directory(self):
volume = u'/Füü/data:/data'
container_path = config.resolve_volume_path(".", volume)
- self.assertEqual(container_path, volume)
+ assert container_path == volume
class MergePathMappingTest(object):
@@ -3380,37 +3371,23 @@ class MergeDevicesTest(unittest.TestCase, MergePathMappingTest):
class BuildOrImageMergeTest(unittest.TestCase):
def test_merge_build_or_image_no_override(self):
- self.assertEqual(
- config.merge_service_dicts({'build': '.'}, {}, V1),
- {'build': '.'},
- )
+ assert config.merge_service_dicts({'build': '.'}, {}, V1) == {'build': '.'}
- self.assertEqual(
- config.merge_service_dicts({'image': 'redis'}, {}, V1),
- {'image': 'redis'},
- )
+ assert config.merge_service_dicts({'image': 'redis'}, {}, V1) == {'image': 'redis'}
def test_merge_build_or_image_override_with_same(self):
- self.assertEqual(
- config.merge_service_dicts({'build': '.'}, {'build': './web'}, V1),
- {'build': './web'},
- )
+ assert config.merge_service_dicts({'build': '.'}, {'build': './web'}, V1) == {'build': './web'}
- self.assertEqual(
- config.merge_service_dicts({'image': 'redis'}, {'image': 'postgres'}, V1),
- {'image': 'postgres'},
- )
+ assert config.merge_service_dicts({'image': 'redis'}, {'image': 'postgres'}, V1) == {
+ 'image': 'postgres'
+ }
def test_merge_build_or_image_override_with_other(self):
- self.assertEqual(
- config.merge_service_dicts({'build': '.'}, {'image': 'redis'}, V1),
- {'image': 'redis'},
- )
+ assert config.merge_service_dicts({'build': '.'}, {'image': 'redis'}, V1) == {
+ 'image': 'redis'
+ }
- self.assertEqual(
- config.merge_service_dicts({'image': 'redis'}, {'build': '.'}, V1),
- {'build': '.'}
- )
+ assert config.merge_service_dicts({'image': 'redis'}, {'build': '.'}, V1) == {'build': '.'}
class MergeListsTest(object):
@@ -3660,7 +3637,7 @@ class MemoryOptionsTest(unittest.TestCase):
'common.yml'
)
).services
- self.assertEqual(service_dict[0]['memswap_limit'], 2000000)
+ assert service_dict[0]['memswap_limit'] == 2000000
def test_memswap_can_be_a_string(self):
service_dict = config.load(
@@ -3670,7 +3647,7 @@ class MemoryOptionsTest(unittest.TestCase):
'common.yml'
)
).services
- self.assertEqual(service_dict[0]['memswap_limit'], "512M")
+ assert service_dict[0]['memswap_limit'] == "512M"
class EnvTest(unittest.TestCase):
@@ -3681,10 +3658,9 @@ class EnvTest(unittest.TestCase):
'CONTAINS_EQUALS=F=2',
'TRAILING_EQUALS=',
]
- self.assertEqual(
- config.parse_environment(environment),
- {'NORMAL': 'F1', 'CONTAINS_EQUALS': 'F=2', 'TRAILING_EQUALS': ''},
- )
+ assert config.parse_environment(environment) == {
+ 'NORMAL': 'F1', 'CONTAINS_EQUALS': 'F=2', 'TRAILING_EQUALS': ''
+ }
def test_parse_environment_as_dict(self):
environment = {
@@ -3692,14 +3668,14 @@ class EnvTest(unittest.TestCase):
'CONTAINS_EQUALS': 'F=2',
'TRAILING_EQUALS': None,
}
- self.assertEqual(config.parse_environment(environment), environment)
+ assert config.parse_environment(environment) == environment
def test_parse_environment_invalid(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.parse_environment('a=b')
def test_parse_environment_empty(self):
- self.assertEqual(config.parse_environment(None), {})
+ assert config.parse_environment(None) == {}
@mock.patch.dict(os.environ)
def test_resolve_environment(self):
@@ -3716,27 +3692,20 @@ class EnvTest(unittest.TestCase):
'NO_DEF': None
},
}
- self.assertEqual(
- resolve_environment(
- service_dict, Environment.from_env_file(None)
- ),
- {'FILE_DEF': 'F1', 'FILE_DEF_EMPTY': '', 'ENV_DEF': 'E3', 'NO_DEF': None},
- )
+ assert resolve_environment(
+ service_dict, Environment.from_env_file(None)
+ ) == {'FILE_DEF': 'F1', 'FILE_DEF_EMPTY': '', 'ENV_DEF': 'E3', 'NO_DEF': None}
def test_resolve_environment_from_env_file(self):
- self.assertEqual(
- resolve_environment({'env_file': ['tests/fixtures/env/one.env']}),
- {'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'bar'},
- )
+ assert resolve_environment({'env_file': ['tests/fixtures/env/one.env']}) == {
+ 'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'bar'
+ }
def test_environment_overrides_env_file(self):
- self.assertEqual(
- resolve_environment({
- 'environment': {'FOO': 'baz'},
- 'env_file': ['tests/fixtures/env/one.env'],
- }),
- {'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'baz'},
- )
+ assert resolve_environment({
+ 'environment': {'FOO': 'baz'},
+ 'env_file': ['tests/fixtures/env/one.env'],
+ }) == {'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'baz'}
def test_resolve_environment_with_multiple_env_files(self):
service_dict = {
@@ -3745,10 +3714,9 @@ class EnvTest(unittest.TestCase):
'tests/fixtures/env/two.env'
]
}
- self.assertEqual(
- resolve_environment(service_dict),
- {'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'baz', 'DOO': 'dah'},
- )
+ assert resolve_environment(service_dict) == {
+ 'ONE': '2', 'TWO': '1', 'THREE': '3', 'FOO': 'baz', 'DOO': 'dah'
+ }
def test_resolve_environment_nonexistent_file(self):
with pytest.raises(ConfigurationError) as exc:
@@ -3764,18 +3732,15 @@ class EnvTest(unittest.TestCase):
os.environ['FILE_DEF'] = 'E1'
os.environ['FILE_DEF_EMPTY'] = 'E2'
os.environ['ENV_DEF'] = 'E3'
- self.assertEqual(
- resolve_environment(
- {'env_file': ['tests/fixtures/env/resolve.env']},
- Environment.from_env_file(None)
- ),
- {
- 'FILE_DEF': u'bär',
- 'FILE_DEF_EMPTY': '',
- 'ENV_DEF': 'E3',
- 'NO_DEF': None
- },
- )
+ assert resolve_environment(
+ {'env_file': ['tests/fixtures/env/resolve.env']},
+ Environment.from_env_file(None)
+ ) == {
+ 'FILE_DEF': u'bär',
+ 'FILE_DEF_EMPTY': '',
+ 'ENV_DEF': 'E3',
+ 'NO_DEF': None
+ }
@mock.patch.dict(os.environ)
def test_resolve_build_args(self):
@@ -3790,10 +3755,9 @@ class EnvTest(unittest.TestCase):
'no_env': None
}
}
- self.assertEqual(
- resolve_build_args(build['args'], Environment.from_env_file(build['context'])),
- {'arg1': 'value1', 'empty_arg': '', 'env_arg': 'value2', 'no_env': None},
- )
+ assert resolve_build_args(build['args'], Environment.from_env_file(build['context'])) == {
+ 'arg1': 'value1', 'empty_arg': '', 'env_arg': 'value2', 'no_env': None
+ }
@pytest.mark.xfail(IS_WINDOWS_PLATFORM, reason='paths use slash')
@mock.patch.dict(os.environ)
@@ -3807,9 +3771,7 @@ class EnvTest(unittest.TestCase):
"tests/fixtures/env",
)
).services[0]
- self.assertEqual(
- set(service_dict['volumes']),
- set([VolumeSpec.parse('/tmp:/host/tmp')]))
+ assert set(service_dict['volumes']) == set([VolumeSpec.parse('/tmp:/host/tmp')])
service_dict = config.load(
build_config_details(
@@ -3817,9 +3779,7 @@ class EnvTest(unittest.TestCase):
"tests/fixtures/env",
)
).services[0]
- self.assertEqual(
- set(service_dict['volumes']),
- set([VolumeSpec.parse('/opt/tmp:/opt/host/tmp')]))
+ assert set(service_dict['volumes']) == set([VolumeSpec.parse('/opt/tmp:/opt/host/tmp')])
def load_from_filename(filename, override_dir=None):
@@ -3833,7 +3793,7 @@ class ExtendsTest(unittest.TestCase):
def test_extends(self):
service_dicts = load_from_filename('tests/fixtures/extends/docker-compose.yml')
- self.assertEqual(service_sort(service_dicts), service_sort([
+ assert service_sort(service_dicts) == service_sort([
{
'name': 'mydb',
'image': 'busybox',
@@ -3851,12 +3811,12 @@ class ExtendsTest(unittest.TestCase):
"BAZ": "2",
},
}
- ]))
+ ])
def test_merging_env_labels_ulimits(self):
service_dicts = load_from_filename('tests/fixtures/extends/common-env-labels-ulimits.yml')
- self.assertEqual(service_sort(service_dicts), service_sort([
+ assert service_sort(service_dicts) == service_sort([
{
'name': 'web',
'image': 'busybox',
@@ -3870,12 +3830,12 @@ class ExtendsTest(unittest.TestCase):
'labels': {'label': 'one'},
'ulimits': {'nproc': 65535, 'memlock': {'soft': 1024, 'hard': 2048}}
}
- ]))
+ ])
def test_nested(self):
service_dicts = load_from_filename('tests/fixtures/extends/nested.yml')
- self.assertEqual(service_dicts, [
+ assert service_dicts == [
{
'name': 'myweb',
'image': 'busybox',
@@ -3886,14 +3846,14 @@ class ExtendsTest(unittest.TestCase):
"BAR": "2",
},
},
- ])
+ ]
def test_self_referencing_file(self):
"""
We specify a 'file' key that is the filename we're already in.
"""
service_dicts = load_from_filename('tests/fixtures/extends/specify-file-as-self.yml')
- self.assertEqual(service_sort(service_dicts), service_sort([
+ assert service_sort(service_dicts) == service_sort([
{
'environment':
{
@@ -3914,7 +3874,7 @@ class ExtendsTest(unittest.TestCase):
'image': 'busybox',
'name': 'web'
}
- ]))
+ ])
def test_circular(self):
with pytest.raises(config.CircularReference) as exc:
@@ -3929,7 +3889,7 @@ class ExtendsTest(unittest.TestCase):
('circle-2.yml', 'other'),
('circle-1.yml', 'web'),
]
- self.assertEqual(path, expected)
+ assert path == expected
def test_extends_validation_empty_dictionary(self):
with pytest.raises(ConfigurationError) as excinfo:
@@ -4021,9 +3981,9 @@ class ExtendsTest(unittest.TestCase):
)
).services
- self.assertEqual(len(service), 1)
- self.assertIsInstance(service[0], dict)
- self.assertEqual(service[0]['command'], "/bin/true")
+ assert len(service) == 1
+ assert isinstance(service[0], dict)
+ assert service[0]['command'] == "/bin/true"
def test_extended_service_with_invalid_config(self):
with pytest.raises(ConfigurationError) as exc:
@@ -4035,7 +3995,7 @@ class ExtendsTest(unittest.TestCase):
def test_extended_service_with_valid_config(self):
service = load_from_filename('tests/fixtures/extends/service-with-valid-composite-extends.yml')
- self.assertEqual(service[0]['command'], "top")
+ assert service[0]['command'] == "top"
def test_extends_file_defaults_to_self(self):
"""
@@ -4043,7 +4003,7 @@ class ExtendsTest(unittest.TestCase):
config is valid and correctly extends from itself.
"""
service_dicts = load_from_filename('tests/fixtures/extends/no-file-specified.yml')
- self.assertEqual(service_sort(service_dicts), service_sort([
+ assert service_sort(service_dicts) == service_sort([
{
'name': 'myweb',
'image': 'busybox',
@@ -4059,7 +4019,7 @@ class ExtendsTest(unittest.TestCase):
"BAZ": "3",
}
}
- ]))
+ ])
def test_invalid_links_in_extended_service(self):
with pytest.raises(ConfigurationError) as excinfo:
@@ -4110,12 +4070,12 @@ class ExtendsTest(unittest.TestCase):
'rw')
]
- self.assertEqual(set(dicts[0]['volumes']), set(paths))
+ assert set(dicts[0]['volumes']) == set(paths)
def test_parent_build_path_dne(self):
child = load_from_filename('tests/fixtures/extends/nonexistent-path-child.yml')
- self.assertEqual(child, [
+ assert child == [
{
'name': 'dnechild',
'image': 'busybox',
@@ -4125,7 +4085,7 @@ class ExtendsTest(unittest.TestCase):
"BAR": "2",
},
},
- ])
+ ]
def test_load_throws_error_when_base_service_does_not_exist(self):
with pytest.raises(ConfigurationError) as excinfo:
@@ -4136,11 +4096,11 @@ class ExtendsTest(unittest.TestCase):
def test_partial_service_config_in_extends_is_still_valid(self):
dicts = load_from_filename('tests/fixtures/extends/valid-common-config.yml')
- self.assertEqual(dicts[0]['environment'], {'FOO': '1'})
+ assert dicts[0]['environment'] == {'FOO': '1'}
def test_extended_service_with_verbose_and_shorthand_way(self):
services = load_from_filename('tests/fixtures/extends/verbose-and-shorthand.yml')
- self.assertEqual(service_sort(services), service_sort([
+ assert service_sort(services) == service_sort([
{
'name': 'base',
'image': 'busybox',
@@ -4156,7 +4116,7 @@ class ExtendsTest(unittest.TestCase):
'image': 'busybox',
'environment': {'BAR': '1', 'FOO': '2'},
},
- ]))
+ ])
@mock.patch.dict(os.environ)
def test_extends_with_environment_and_env_files(self):
@@ -4267,7 +4227,7 @@ class ExtendsTest(unittest.TestCase):
""")
service = load_from_filename(str(tmpdir.join('docker-compose.yml')))
- self.assertEqual(service[0]['command'], "top")
+ assert service[0]['command'] == "top"
def test_extends_with_depends_on(self):
tmpdir = py.test.ensuretemp('test_extends_with_depends_on')
@@ -4331,12 +4291,12 @@ class ExpandPathTest(unittest.TestCase):
def test_expand_path_normal(self):
result = config.expand_path(self.working_dir, 'myfile')
- self.assertEqual(result, self.working_dir + '/' + 'myfile')
+ assert result == self.working_dir + '/' + 'myfile'
def test_expand_path_absolute(self):
abs_path = '/home/user/otherdir/somefile'
result = config.expand_path(self.working_dir, abs_path)
- self.assertEqual(result, abs_path)
+ assert result == abs_path
def test_expand_path_with_tilde(self):
test_path = '~/otherdir/somefile'
@@ -4344,7 +4304,7 @@ class ExpandPathTest(unittest.TestCase):
os.environ['HOME'] = user_path = '/home/user/'
result = config.expand_path(self.working_dir, test_path)
- self.assertEqual(result, user_path + 'otherdir/somefile')
+ assert result == user_path + 'otherdir/somefile'
class VolumePathTest(unittest.TestCase):
@@ -4380,7 +4340,7 @@ class BuildPathTest(unittest.TestCase):
self.abs_context_path = os.path.join(os.getcwd(), 'tests/fixtures/build-ctx')
def test_nonexistent_path(self):
- with self.assertRaises(ConfigurationError):
+ with pytest.raises(ConfigurationError):
config.load(
build_config_details(
{
@@ -4398,7 +4358,7 @@ class BuildPathTest(unittest.TestCase):
{'build': relative_build_path},
working_dir='tests/fixtures/build-path'
)
- self.assertEqual(service_dict['build'], self.abs_context_path)
+ assert service_dict['build'] == self.abs_context_path
def test_absolute_path(self):
service_dict = make_service_dict(
@@ -4406,17 +4366,17 @@ class BuildPathTest(unittest.TestCase):
{'build': self.abs_context_path},
working_dir='tests/fixtures/build-path'
)
- self.assertEqual(service_dict['build'], self.abs_context_path)
+ assert service_dict['build'] == self.abs_context_path
def test_from_file(self):
service_dict = load_from_filename('tests/fixtures/build-path/docker-compose.yml')
- self.assertEqual(service_dict, [{'name': 'foo', 'build': {'context': self.abs_context_path}}])
+ assert service_dict == [{'name': 'foo', 'build': {'context': self.abs_context_path}}]
def test_from_file_override_dir(self):
override_dir = os.path.join(os.getcwd(), 'tests/fixtures/')
service_dict = load_from_filename(
'tests/fixtures/build-path-override-dir/docker-compose.yml', override_dir=override_dir)
- self.assertEquals(service_dict, [{'name': 'foo', 'build': {'context': self.abs_context_path}}])
+ assert service_dict == [{'name': 'foo', 'build': {'context': self.abs_context_path}}]
def test_valid_url_in_build_path(self):
valid_urls = [
@@ -4557,10 +4517,8 @@ class GetDefaultConfigFilesTestCase(unittest.TestCase):
def test_get_config_path_default_file_in_basedir(self):
for index, filename in enumerate(self.files):
- self.assertEqual(
- filename,
- get_config_filename_for_files(self.files[index:]))
- with self.assertRaises(config.ComposeFileNotFound):
+ assert filename == get_config_filename_for_files(self.files[index:])
+ with pytest.raises(config.ComposeFileNotFound):
get_config_filename_for_files([])
def test_get_config_path_default_file_in_parent_dir(self):
@@ -4570,8 +4528,8 @@ class GetDefaultConfigFilesTestCase(unittest.TestCase):
return get_config_filename_for_files(files, subdir=True)
for index, filename in enumerate(self.files):
- self.assertEqual(filename, get_config_in_subdir(self.files[index:]))
- with self.assertRaises(config.ComposeFileNotFound):
+ assert filename == get_config_in_subdir(self.files[index:])
+ with pytest.raises(config.ComposeFileNotFound):
get_config_in_subdir([])
diff --git a/tests/unit/container_test.py b/tests/unit/container_test.py
index 04f430162..0fcf23fa6 100644
--- a/tests/unit/container_test.py
+++ b/tests/unit/container_test.py
@@ -39,13 +39,11 @@ class ContainerTest(unittest.TestCase):
container = Container.from_ps(None,
self.container_dict,
has_been_inspected=True)
- self.assertEqual(
- container.dictionary,
- {
- "Id": self.container_id,
- "Image": "busybox:latest",
- "Name": "/composetest_db_1",
- })
+ assert container.dictionary == {
+ "Id": self.container_id,
+ "Image": "busybox:latest",
+ "Name": "/composetest_db_1",
+ }
def test_from_ps_prefixed(self):
self.container_dict['Names'] = [
@@ -56,11 +54,11 @@ class ContainerTest(unittest.TestCase):
None,
self.container_dict,
has_been_inspected=True)
- self.assertEqual(container.dictionary, {
+ assert container.dictionary == {
"Id": self.container_id,
"Image": "busybox:latest",
"Name": "/composetest_db_1",
- })
+ }
def test_environment(self):
container = Container(None, {
@@ -72,30 +70,30 @@ class ContainerTest(unittest.TestCase):
]
}
}, has_been_inspected=True)
- self.assertEqual(container.environment, {
+ assert container.environment == {
'FOO': 'BAR',
'BAZ': 'DOGE',
- })
+ }
def test_number(self):
container = Container(None, self.container_dict, has_been_inspected=True)
- self.assertEqual(container.number, 7)
+ assert container.number == 7
def test_name(self):
container = Container.from_ps(None,
self.container_dict,
has_been_inspected=True)
- self.assertEqual(container.name, "composetest_db_1")
+ assert container.name == "composetest_db_1"
def test_name_without_project(self):
self.container_dict['Name'] = "/composetest_web_7"
container = Container(None, self.container_dict, has_been_inspected=True)
- self.assertEqual(container.name_without_project, "web_7")
+ assert container.name_without_project == "web_7"
def test_name_without_project_custom_container_name(self):
self.container_dict['Name'] = "/custom_name_of_container"
container = Container(None, self.container_dict, has_been_inspected=True)
- self.assertEqual(container.name_without_project, "custom_name_of_container")
+ assert container.name_without_project == "custom_name_of_container"
def test_inspect_if_not_inspected(self):
mock_client = mock.create_autospec(docker.APIClient)
@@ -103,16 +101,15 @@ class ContainerTest(unittest.TestCase):
container.inspect_if_not_inspected()
mock_client.inspect_container.assert_called_once_with("the_id")
- self.assertEqual(container.dictionary,
- mock_client.inspect_container.return_value)
- self.assertTrue(container.has_been_inspected)
+ assert container.dictionary == mock_client.inspect_container.return_value
+ assert container.has_been_inspected
container.inspect_if_not_inspected()
- self.assertEqual(mock_client.inspect_container.call_count, 1)
+ assert mock_client.inspect_container.call_count == 1
def test_human_readable_ports_none(self):
container = Container(None, self.container_dict, has_been_inspected=True)
- self.assertEqual(container.human_readable_ports, '')
+ assert container.human_readable_ports == ''
def test_human_readable_ports_public_and_private(self):
self.container_dict['NetworkSettings']['Ports'].update({
@@ -122,7 +119,7 @@ class ContainerTest(unittest.TestCase):
container = Container(None, self.container_dict, has_been_inspected=True)
expected = "45453/tcp, 0.0.0.0:49197->45454/tcp"
- self.assertEqual(container.human_readable_ports, expected)
+ assert container.human_readable_ports == expected
def test_get_local_port(self):
self.container_dict['NetworkSettings']['Ports'].update({
@@ -130,9 +127,7 @@ class ContainerTest(unittest.TestCase):
})
container = Container(None, self.container_dict, has_been_inspected=True)
- self.assertEqual(
- container.get_local_port(45454, protocol='tcp'),
- '0.0.0.0:49197')
+ assert container.get_local_port(45454, protocol='tcp') == '0.0.0.0:49197'
def test_get(self):
container = Container(None, {
@@ -142,9 +137,9 @@ class ContainerTest(unittest.TestCase):
},
}, has_been_inspected=True)
- self.assertEqual(container.get('Status'), "Up 8 seconds")
- self.assertEqual(container.get('HostConfig.VolumesFrom'), ["volume_id"])
- self.assertEqual(container.get('Foo.Bar.DoesNotExist'), None)
+ assert container.get('Status') == "Up 8 seconds"
+ assert container.get('HostConfig.VolumesFrom') == ["volume_id"]
+ assert container.get('Foo.Bar.DoesNotExist') is None
def test_short_id(self):
container = Container(None, self.container_dict, has_been_inspected=True)
@@ -182,17 +177,14 @@ class ContainerTest(unittest.TestCase):
class GetContainerNameTestCase(unittest.TestCase):
def test_get_container_name(self):
- self.assertIsNone(get_container_name({}))
- self.assertEqual(get_container_name({'Name': 'myproject_db_1'}), 'myproject_db_1')
- self.assertEqual(
- get_container_name({'Names': ['/myproject_db_1', '/myproject_web_1/db']}),
- 'myproject_db_1')
- self.assertEqual(
- get_container_name({
- 'Names': [
- '/swarm-host-1/myproject_db_1',
- '/swarm-host-1/myproject_web_1/db'
- ]
- }),
- 'myproject_db_1'
- )
+ assert get_container_name({}) is None
+ assert get_container_name({'Name': 'myproject_db_1'}) == 'myproject_db_1'
+ assert get_container_name(
+ {'Names': ['/myproject_db_1', '/myproject_web_1/db']}
+ ) == 'myproject_db_1'
+ assert get_container_name({
+ 'Names': [
+ '/swarm-host-1/myproject_db_1',
+ '/swarm-host-1/myproject_web_1/db'
+ ]
+ }) == 'myproject_db_1'
diff --git a/tests/unit/progress_stream_test.py b/tests/unit/progress_stream_test.py
index c0cb906dd..22a6e081b 100644
--- a/tests/unit/progress_stream_test.py
+++ b/tests/unit/progress_stream_test.py
@@ -15,7 +15,7 @@ class ProgressStreamTestCase(unittest.TestCase):
b'"progress": "..."}',
]
events = progress_stream.stream_output(output, StringIO())
- self.assertEqual(len(events), 1)
+ assert len(events) == 1
def test_stream_output_div_zero(self):
output = [
@@ -24,7 +24,7 @@ class ProgressStreamTestCase(unittest.TestCase):
b'"progress": "..."}',
]
events = progress_stream.stream_output(output, StringIO())
- self.assertEqual(len(events), 1)
+ assert len(events) == 1
def test_stream_output_null_total(self):
output = [
@@ -33,7 +33,7 @@ class ProgressStreamTestCase(unittest.TestCase):
b'"progress": "..."}',
]
events = progress_stream.stream_output(output, StringIO())
- self.assertEqual(len(events), 1)
+ assert len(events) == 1
def test_stream_output_progress_event_tty(self):
events = [
@@ -46,7 +46,7 @@ class ProgressStreamTestCase(unittest.TestCase):
output = TTYStringIO()
events = progress_stream.stream_output(events, output)
- self.assertTrue(len(output.getvalue()) > 0)
+ assert len(output.getvalue()) > 0
def test_stream_output_progress_event_no_tty(self):
events = [
@@ -55,7 +55,7 @@ class ProgressStreamTestCase(unittest.TestCase):
output = StringIO()
events = progress_stream.stream_output(events, output)
- self.assertEqual(len(output.getvalue()), 0)
+ assert len(output.getvalue()) == 0
def test_stream_output_no_progress_event_no_tty(self):
events = [
@@ -64,7 +64,7 @@ class ProgressStreamTestCase(unittest.TestCase):
output = StringIO()
events = progress_stream.stream_output(events, output)
- self.assertTrue(len(output.getvalue()) > 0)
+ assert len(output.getvalue()) > 0
def test_get_digest_from_push():
diff --git a/tests/unit/project_test.py b/tests/unit/project_test.py
index e5f1a175f..1313fbe35 100644
--- a/tests/unit/project_test.py
+++ b/tests/unit/project_test.py
@@ -46,12 +46,12 @@ class ProjectTest(unittest.TestCase):
config_data=config,
client=None,
)
- self.assertEqual(len(project.services), 2)
- self.assertEqual(project.get_service('web').name, 'web')
- self.assertEqual(project.get_service('web').options['image'], 'busybox:latest')
- self.assertEqual(project.get_service('db').name, 'db')
- self.assertEqual(project.get_service('db').options['image'], 'busybox:latest')
- self.assertFalse(project.networks.use_networking)
+ assert len(project.services) == 2
+ assert project.get_service('web').name == 'web'
+ assert project.get_service('web').options['image'] == 'busybox:latest'
+ assert project.get_service('db').name == 'db'
+ assert project.get_service('db').options['image'] == 'busybox:latest'
+ assert not project.networks.use_networking
def test_from_config_v2(self):
config = Config(
@@ -72,8 +72,8 @@ class ProjectTest(unittest.TestCase):
configs=None,
)
project = Project.from_config('composetest', config, None)
- self.assertEqual(len(project.services), 2)
- self.assertTrue(project.networks.use_networking)
+ assert len(project.services) == 2
+ assert project.networks.use_networking
def test_get_service(self):
web = Service(
@@ -83,7 +83,7 @@ class ProjectTest(unittest.TestCase):
image="busybox:latest",
)
project = Project('test', [web], None)
- self.assertEqual(project.get_service('web'), web)
+ assert project.get_service('web') == web
def test_get_services_returns_all_services_without_args(self):
web = Service(
@@ -97,7 +97,7 @@ class ProjectTest(unittest.TestCase):
image='foo',
)
project = Project('test', [web, console], None)
- self.assertEqual(project.get_services(), [web, console])
+ assert project.get_services() == [web, console]
def test_get_services_returns_listed_services_with_args(self):
web = Service(
@@ -111,7 +111,7 @@ class ProjectTest(unittest.TestCase):
image='foo',
)
project = Project('test', [web, console], None)
- self.assertEqual(project.get_services(['console']), [console])
+ assert project.get_services(['console']) == [console]
def test_get_services_with_include_links(self):
db = Service(
@@ -137,10 +137,7 @@ class ProjectTest(unittest.TestCase):
links=[(web, 'web')]
)
project = Project('test', [web, db, cache, console], None)
- self.assertEqual(
- project.get_services(['console'], include_deps=True),
- [db, web, console]
- )
+ assert project.get_services(['console'], include_deps=True) == [db, web, console]
def test_get_services_removes_duplicates_following_links(self):
db = Service(
@@ -155,10 +152,7 @@ class ProjectTest(unittest.TestCase):
links=[(db, 'database')]
)
project = Project('test', [web, db], None)
- self.assertEqual(
- project.get_services(['web', 'db'], include_deps=True),
- [db, web]
- )
+ assert project.get_services(['web', 'db'], include_deps=True) == [db, web]
def test_use_volumes_from_container(self):
container_id = 'aabbccddee'
@@ -377,8 +371,8 @@ class ProjectTest(unittest.TestCase):
),
)
service = project.get_service('test')
- self.assertEqual(service.network_mode.id, None)
- self.assertNotIn('NetworkMode', service._get_container_host_config({}))
+ assert service.network_mode.id is None
+ assert 'NetworkMode' not in service._get_container_host_config({})
def test_use_net_from_container(self):
container_id = 'aabbccddee'
@@ -403,7 +397,7 @@ class ProjectTest(unittest.TestCase):
),
)
service = project.get_service('test')
- self.assertEqual(service.network_mode.mode, 'container:' + container_id)
+ assert service.network_mode.mode == 'container:' + container_id
def test_use_net_from_service(self):
container_name = 'test_aaa_1'
@@ -439,7 +433,7 @@ class ProjectTest(unittest.TestCase):
)
service = project.get_service('test')
- self.assertEqual(service.network_mode.mode, 'container:' + container_name)
+ assert service.network_mode.mode == 'container:' + container_name
def test_uses_default_network_true(self):
project = Project.from_config(
@@ -513,7 +507,7 @@ class ProjectTest(unittest.TestCase):
configs=None,
),
)
- self.assertEqual([c.id for c in project.containers()], ['1'])
+ assert [c.id for c in project.containers()] == ['1']
def test_down_with_no_resources(self):
project = Project.from_config(
diff --git a/tests/unit/service_test.py b/tests/unit/service_test.py
index 24ed60e94..92d7f08d5 100644
--- a/tests/unit/service_test.py
+++ b/tests/unit/service_test.py
@@ -46,14 +46,14 @@ class ServiceTest(unittest.TestCase):
def test_containers(self):
service = Service('db', self.mock_client, 'myproject', image='foo')
self.mock_client.containers.return_value = []
- self.assertEqual(list(service.containers()), [])
+ assert list(service.containers()) == []
def test_containers_with_containers(self):
self.mock_client.containers.return_value = [
dict(Name=str(i), Image='foo', Id=i) for i in range(3)
]
service = Service('db', self.mock_client, 'myproject', image='foo')
- self.assertEqual([c.id for c in service.containers()], list(range(3)))
+ assert [c.id for c in service.containers()] == list(range(3))
expected_labels = [
'{0}=myproject'.format(LABEL_PROJECT),
@@ -73,9 +73,9 @@ class ServiceTest(unittest.TestCase):
]
service = Service('db', self.mock_client, 'myproject', image='foo')
- self.assertEqual([c.id for c in service.containers()], ['1'])
- self.assertEqual(service._next_container_number(), 2)
- self.assertEqual(service.get_container(1).id, '1')
+ assert [c.id for c in service.containers()] == ['1']
+ assert service._next_container_number() == 2
+ assert service.get_container(1).id == '1'
def test_get_volumes_from_container(self):
container_id = 'aabbccddee'
@@ -88,7 +88,7 @@ class ServiceTest(unittest.TestCase):
'rw',
'container')])
- self.assertEqual(service._get_volumes_from(), [container_id + ':rw'])
+ assert service._get_volumes_from() == [container_id + ':rw']
def test_get_volumes_from_container_read_only(self):
container_id = 'aabbccddee'
@@ -101,7 +101,7 @@ class ServiceTest(unittest.TestCase):
'ro',
'container')])
- self.assertEqual(service._get_volumes_from(), [container_id + ':ro'])
+ assert service._get_volumes_from() == [container_id + ':ro']
def test_get_volumes_from_service_container_exists(self):
container_ids = ['aabbccddee', '12345']
@@ -115,7 +115,7 @@ class ServiceTest(unittest.TestCase):
volumes_from=[VolumeFromSpec(from_service, 'rw', 'service')],
image='foo')
- self.assertEqual(service._get_volumes_from(), [container_ids[0] + ":rw"])
+ assert service._get_volumes_from() == [container_ids[0] + ":rw"]
def test_get_volumes_from_service_container_exists_with_flags(self):
for mode in ['ro', 'rw', 'z', 'rw,z', 'z,rw']:
@@ -130,7 +130,7 @@ class ServiceTest(unittest.TestCase):
volumes_from=[VolumeFromSpec(from_service, mode, 'service')],
image='foo')
- self.assertEqual(service._get_volumes_from(), [container_ids[0]])
+ assert service._get_volumes_from() == [container_ids[0]]
def test_get_volumes_from_service_no_container(self):
container_id = 'abababab'
@@ -144,7 +144,7 @@ class ServiceTest(unittest.TestCase):
image='foo',
volumes_from=[VolumeFromSpec(from_service, 'rw', 'service')])
- self.assertEqual(service._get_volumes_from(), [container_id + ':rw'])
+ assert service._get_volumes_from() == [container_id + ':rw']
from_service.create_container.assert_called_once_with()
def test_memory_swap_limit(self):
@@ -159,22 +159,16 @@ class ServiceTest(unittest.TestCase):
memswap_limit=2000000000)
service._get_container_create_options({'some': 'overrides'}, 1)
- self.assertTrue(self.mock_client.create_host_config.called)
- self.assertEqual(
- self.mock_client.create_host_config.call_args[1]['mem_limit'],
- 1000000000
- )
- self.assertEqual(
- self.mock_client.create_host_config.call_args[1]['memswap_limit'],
- 2000000000
- )
+ assert self.mock_client.create_host_config.called
+ assert self.mock_client.create_host_config.call_args[1]['mem_limit'] == 1000000000
+ assert self.mock_client.create_host_config.call_args[1]['memswap_limit'] == 2000000000
def test_self_reference_external_link(self):
service = Service(
name='foo',
external_links=['default_foo_1']
)
- with self.assertRaises(DependencyError):
+ with pytest.raises(DependencyError):
service.get_container_name('foo', 1)
def test_mem_reservation(self):
@@ -202,11 +196,8 @@ class ServiceTest(unittest.TestCase):
cgroup_parent='test')
service._get_container_create_options({'some': 'overrides'}, 1)
- self.assertTrue(self.mock_client.create_host_config.called)
- self.assertEqual(
- self.mock_client.create_host_config.call_args[1]['cgroup_parent'],
- 'test'
- )
+ assert self.mock_client.create_host_config.called
+ assert self.mock_client.create_host_config.call_args[1]['cgroup_parent'] == 'test'
def test_log_opt(self):
self.mock_client.create_host_config.return_value = {}
@@ -222,11 +213,10 @@ class ServiceTest(unittest.TestCase):
logging=logging)
service._get_container_create_options({'some': 'overrides'}, 1)
- self.assertTrue(self.mock_client.create_host_config.called)
- self.assertEqual(
- self.mock_client.create_host_config.call_args[1]['log_config'],
- {'Type': 'syslog', 'Config': {'syslog-address': 'tcp://192.168.0.42:123'}}
- )
+ assert self.mock_client.create_host_config.called
+ assert self.mock_client.create_host_config.call_args[1]['log_config'] == {
+ 'Type': 'syslog', 'Config': {'syslog-address': 'tcp://192.168.0.42:123'}
+ }
def test_stop_grace_period(self):
self.mock_client.api_version = '1.25'
@@ -237,7 +227,7 @@ class ServiceTest(unittest.TestCase):
client=self.mock_client,
stop_grace_period="1m35s")
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertEqual(opts['stop_timeout'], 95)
+ assert opts['stop_timeout'] == 95
def test_split_domainname_none(self):
service = Service(
@@ -246,8 +236,8 @@ class ServiceTest(unittest.TestCase):
hostname='name.domain.tld',
client=self.mock_client)
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertEqual(opts['hostname'], 'name.domain.tld', 'hostname')
- self.assertFalse('domainname' in opts, 'domainname')
+ assert opts['hostname'] == 'name.domain.tld', 'hostname'
+ assert not ('domainname' in opts), 'domainname'
def test_split_domainname_fqdn(self):
self.mock_client.api_version = '1.22'
@@ -257,8 +247,8 @@ class ServiceTest(unittest.TestCase):
image='foo',
client=self.mock_client)
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertEqual(opts['hostname'], 'name', 'hostname')
- self.assertEqual(opts['domainname'], 'domain.tld', 'domainname')
+ assert opts['hostname'] == 'name', 'hostname'
+ assert opts['domainname'] == 'domain.tld', 'domainname'
def test_split_domainname_both(self):
self.mock_client.api_version = '1.22'
@@ -269,8 +259,8 @@ class ServiceTest(unittest.TestCase):
domainname='domain.tld',
client=self.mock_client)
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertEqual(opts['hostname'], 'name', 'hostname')
- self.assertEqual(opts['domainname'], 'domain.tld', 'domainname')
+ assert opts['hostname'] == 'name', 'hostname'
+ assert opts['domainname'] == 'domain.tld', 'domainname'
def test_split_domainname_weird(self):
self.mock_client.api_version = '1.22'
@@ -281,8 +271,8 @@ class ServiceTest(unittest.TestCase):
image='foo',
client=self.mock_client)
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertEqual(opts['hostname'], 'name.sub', 'hostname')
- self.assertEqual(opts['domainname'], 'domain.tld', 'domainname')
+ assert opts['hostname'] == 'name.sub', 'hostname'
+ assert opts['domainname'] == 'domain.tld', 'domainname'
def test_no_default_hostname_when_not_using_networking(self):
service = Service(
@@ -292,7 +282,7 @@ class ServiceTest(unittest.TestCase):
client=self.mock_client,
)
opts = service._get_container_create_options({'image': 'foo'}, 1)
- self.assertIsNone(opts.get('hostname'))
+ assert opts.get('hostname') is None
def test_get_container_create_options_with_name_option(self):
service = Service(
@@ -305,7 +295,7 @@ class ServiceTest(unittest.TestCase):
{'name': name},
1,
one_off=OneOffFilter.only)
- self.assertEqual(opts['name'], name)
+ assert opts['name'] == name
def test_get_container_create_options_does_not_mutate_options(self):
labels = {'thing': 'real'}
@@ -328,12 +318,11 @@ class ServiceTest(unittest.TestCase):
1,
previous_container=prev_container)
- self.assertEqual(service.options['labels'], labels)
- self.assertEqual(service.options['environment'], environment)
+ assert service.options['labels'] == labels
+ assert service.options['environment'] == environment
- self.assertEqual(
- opts['labels'][LABEL_CONFIG_HASH],
- '2524a06fcb3d781aa2c981fc40bcfa08013bb318e4273bfa388df22023e6f2aa')
+ assert opts['labels'][LABEL_CONFIG_HASH] == \
+ '2524a06fcb3d781aa2c981fc40bcfa08013bb318e4273bfa388df22023e6f2aa'
assert opts['environment'] == ['also=real']
def test_get_container_create_options_sets_affinity_with_binds(self):
@@ -385,7 +374,8 @@ class ServiceTest(unittest.TestCase):
self.mock_client.containers.return_value = []
service = Service('foo', client=self.mock_client, image='foo')
- self.assertRaises(ValueError, service.get_container)
+ with pytest.raises(ValueError):
+ service.get_container()
@mock.patch('compose.service.Container', autospec=True)
def test_get_container(self, mock_container_class):
@@ -394,7 +384,7 @@ class ServiceTest(unittest.TestCase):
service = Service('foo', image='foo', client=self.mock_client)
container = service.get_container(number=2)
- self.assertEqual(container, mock_container_class.from_ps.return_value)
+ assert container == mock_container_class.from_ps.return_value
mock_container_class.from_ps.assert_called_once_with(
self.mock_client, container_dict)
@@ -449,23 +439,17 @@ class ServiceTest(unittest.TestCase):
mock_container.stop.assert_called_once_with(timeout=1)
def test_parse_repository_tag(self):
- self.assertEqual(parse_repository_tag("root"), ("root", "", ":"))
- self.assertEqual(parse_repository_tag("root:tag"), ("root", "tag", ":"))
- self.assertEqual(parse_repository_tag("user/repo"), ("user/repo", "", ":"))
- self.assertEqual(parse_repository_tag("user/repo:tag"), ("user/repo", "tag", ":"))
- self.assertEqual(parse_repository_tag("url:5000/repo"), ("url:5000/repo", "", ":"))
- self.assertEqual(
- parse_repository_tag("url:5000/repo:tag"),
- ("url:5000/repo", "tag", ":"))
- self.assertEqual(
- parse_repository_tag("root@sha256:digest"),
- ("root", "sha256:digest", "@"))
- self.assertEqual(
- parse_repository_tag("user/repo@sha256:digest"),
- ("user/repo", "sha256:digest", "@"))
- self.assertEqual(
- parse_repository_tag("url:5000/repo@sha256:digest"),
- ("url:5000/repo", "sha256:digest", "@"))
+ assert parse_repository_tag("root") == ("root", "", ":")
+ assert parse_repository_tag("root:tag") == ("root", "tag", ":")
+ assert parse_repository_tag("user/repo") == ("user/repo", "", ":")
+ assert parse_repository_tag("user/repo:tag") == ("user/repo", "tag", ":")
+ assert parse_repository_tag("url:5000/repo") == ("url:5000/repo", "", ":")
+ assert parse_repository_tag("url:5000/repo:tag") == ("url:5000/repo", "tag", ":")
+ assert parse_repository_tag("root@sha256:digest") == ("root", "sha256:digest", "@")
+ assert parse_repository_tag("user/repo@sha256:digest") == ("user/repo", "sha256:digest", "@")
+ assert parse_repository_tag("url:5000/repo@sha256:digest") == (
+ "url:5000/repo", "sha256:digest", "@"
+ )
def test_create_container(self):
service = Service('foo', client=self.mock_client, build={'context': '.'})
@@ -553,8 +537,8 @@ class ServiceTest(unittest.TestCase):
service = Service('foo', client=self.mock_client, build={'context': '.'})
service.build()
- self.assertEqual(self.mock_client.build.call_count, 1)
- self.assertFalse(self.mock_client.build.call_args[1]['pull'])
+ assert self.mock_client.build.call_count == 1
+ assert not self.mock_client.build.call_args[1]['pull']
def test_build_with_override_build_args(self):
self.mock_client.build.return_value = [
@@ -653,63 +637,63 @@ class ServiceTest(unittest.TestCase):
service = Service(
'foo',
image='foo')
- self.assertEqual(service.specifies_host_port(), False)
+ assert not service.specifies_host_port()
def test_specifies_host_port_with_container_port(self):
service = Service(
'foo',
image='foo',
ports=["2000"])
- self.assertEqual(service.specifies_host_port(), False)
+ assert not service.specifies_host_port()
def test_specifies_host_port_with_host_port(self):
service = Service(
'foo',
image='foo',
ports=["1000:2000"])
- self.assertEqual(service.specifies_host_port(), True)
+ assert service.specifies_host_port()
def test_specifies_host_port_with_host_ip_no_port(self):
service = Service(
'foo',
image='foo',
ports=["127.0.0.1::2000"])
- self.assertEqual(service.specifies_host_port(), False)
+ assert not service.specifies_host_port()
def test_specifies_host_port_with_host_ip_and_port(self):
service = Service(
'foo',
image='foo',
ports=["127.0.0.1:1000:2000"])
- self.assertEqual(service.specifies_host_port(), True)
+ assert service.specifies_host_port()
def test_specifies_host_port_with_container_port_range(self):
service = Service(
'foo',
image='foo',
ports=["2000-3000"])
- self.assertEqual(service.specifies_host_port(), False)
+ assert not service.specifies_host_port()
def test_specifies_host_port_with_host_port_range(self):
service = Service(
'foo',
image='foo',
ports=["1000-2000:2000-3000"])
- self.assertEqual(service.specifies_host_port(), True)
+ assert service.specifies_host_port()
def test_specifies_host_port_with_host_ip_no_port_range(self):
service = Service(
'foo',
image='foo',
ports=["127.0.0.1::2000-3000"])
- self.assertEqual(service.specifies_host_port(), False)
+ assert not service.specifies_host_port()
def test_specifies_host_port_with_host_ip_and_port_range(self):
service = Service(
'foo',
image='foo',
ports=["127.0.0.1:1000-2000:2000-3000"])
- self.assertEqual(service.specifies_host_port(), True)
+ assert service.specifies_host_port()
def test_image_name_from_config(self):
image_name = 'example/web:latest'
@@ -730,10 +714,10 @@ class ServiceTest(unittest.TestCase):
ports=["8080:80"])
service.scale(0)
- self.assertFalse(mock_log.warn.called)
+ assert not mock_log.warn.called
service.scale(1)
- self.assertFalse(mock_log.warn.called)
+ assert not mock_log.warn.called
service.scale(2)
mock_log.warn.assert_called_once_with(
@@ -815,16 +799,16 @@ class NetTestCase(unittest.TestCase):
def test_network_mode(self):
network_mode = NetworkMode('host')
- self.assertEqual(network_mode.id, 'host')
- self.assertEqual(network_mode.mode, 'host')
- self.assertEqual(network_mode.service_name, None)
+ assert network_mode.id == 'host'
+ assert network_mode.mode == 'host'
+ assert network_mode.service_name is None
def test_network_mode_container(self):
container_id = 'abcd'
network_mode = ContainerNetworkMode(Container(None, {'Id': container_id}))
- self.assertEqual(network_mode.id, container_id)
- self.assertEqual(network_mode.mode, 'container:' + container_id)
- self.assertEqual(network_mode.service_name, None)
+ assert network_mode.id == container_id
+ assert network_mode.mode == 'container:' + container_id
+ assert network_mode.service_name is None
def test_network_mode_service(self):
container_id = 'bbbb'
@@ -837,9 +821,9 @@ class NetTestCase(unittest.TestCase):
service = Service(name=service_name, client=mock_client)
network_mode = ServiceNetworkMode(service)
- self.assertEqual(network_mode.id, service_name)
- self.assertEqual(network_mode.mode, 'container:' + container_id)
- self.assertEqual(network_mode.service_name, service_name)
+ assert network_mode.id == service_name
+ assert network_mode.mode == 'container:' + container_id
+ assert network_mode.service_name == service_name
def test_network_mode_service_no_containers(self):
service_name = 'web'
@@ -849,9 +833,9 @@ class NetTestCase(unittest.TestCase):
service = Service(name=service_name, client=mock_client)
network_mode = ServiceNetworkMode(service)
- self.assertEqual(network_mode.id, service_name)
- self.assertEqual(network_mode.mode, None)
- self.assertEqual(network_mode.service_name, service_name)
+ assert network_mode.id == service_name
+ assert network_mode.mode is None
+ assert network_mode.service_name == service_name
class ServicePortsTest(unittest.TestCase):
@@ -1002,13 +986,10 @@ class ServiceVolumesTest(unittest.TestCase):
number=1,
)
- self.assertEqual(
- set(self.mock_client.create_host_config.call_args[1]['binds']),
- set([
- '/host/path:/data1:rw',
- '/host/path:/data2:rw',
- ]),
- )
+ assert set(self.mock_client.create_host_config.call_args[1]['binds']) == set([
+ '/host/path:/data1:rw',
+ '/host/path:/data2:rw',
+ ])
def test_get_container_create_options_with_different_host_path_in_container_json(self):
service = Service(
@@ -1113,9 +1094,7 @@ class ServiceVolumesTest(unittest.TestCase):
).create_container()
assert self.mock_client.create_container.call_count == 1
- self.assertEqual(
- self.mock_client.create_host_config.call_args[1]['binds'],
- [volume])
+ assert self.mock_client.create_host_config.call_args[1]['binds'] == [volume]
class ServiceSecretTest(unittest.TestCase):
diff --git a/tests/unit/split_buffer_test.py b/tests/unit/split_buffer_test.py
index c41ea27d4..dedd4ee36 100644
--- a/tests/unit/split_buffer_test.py
+++ b/tests/unit/split_buffer_test.py
@@ -50,5 +50,5 @@ class SplitBufferTest(unittest.TestCase):
split = split_buffer(reader())
for (actual, expected) in zip(split, expectations):
- self.assertEqual(type(actual), type(expected))
- self.assertEqual(actual, expected)
+ assert type(actual) == type(expected)
+ assert actual == expected