tyler.durden
/
compose
mirror of https://github.com/docker/compose.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Replace unittest-style asserts with pytest asserts 

Signed-off-by: Joffrey F <joffrey@docker.com>
This commit is contained in:
Joffrey F 2018-01-04 13:01:54 -08:00
parent ddbc9e30b0
commit b13ec16e11
14 changed files with 807 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
tests/acceptance/cli_test.py
View File

@ -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

239
tests/integration/project_test.py
View File

@ -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()

12
tests/integration/resilience_test.py
View File

@ -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):

364
tests/integration/service_test.py
View File

@ -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

83
tests/integration/state_test.py
View File

@ -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

2
tests/unit/cli/docker_client_test.py
View File

@ -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):

8
tests/unit/cli/verbose_proxy_test.py
View File

@ -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

29
tests/unit/cli_test.py
View File

@ -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,

352
tests/unit/config/config_test.py
View File

@ -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([])

74
tests/unit/container_test.py
View File

@ -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'

12
tests/unit/progress_stream_test.py
View File

@ -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():

42
tests/unit/project_test.py
View File

@ -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(

179
tests/unit/service_test.py
View File

@ -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):

4
tests/unit/split_buffer_test.py
View File

@ -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