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