Replace unittest-style asserts with pytest asserts

Signed-off-by: Joffrey F <[email protected]>

tests/acceptance/cli_test.py

@@ -474,9 +474,9 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'])
         result = self.dispatch(['ps'])
 
-        self.assertIn('multiplecomposefiles_simple_1', result.stdout)
-        self.assertIn('multiplecomposefiles_another_1', result.stdout)
-        self.assertNotIn('multiplecomposefiles_yetanother_1', result.stdout)
+        assert 'multiplecomposefiles_simple_1' in result.stdout
+        assert 'multiplecomposefiles_another_1' in result.stdout
+        assert 'multiplecomposefiles_yetanother_1' not in result.stdout
 
     def test_ps_alternate_composefile(self):
         config_path = os.path.abspath(
@@ -487,9 +487,9 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['-f', 'compose2.yml', 'up', '-d'])
         result = self.dispatch(['-f', 'compose2.yml', 'ps'])
 
-        self.assertNotIn('multiplecomposefiles_simple_1', result.stdout)
-        self.assertNotIn('multiplecomposefiles_another_1', result.stdout)
-        self.assertIn('multiplecomposefiles_yetanother_1', result.stdout)
+        assert 'multiplecomposefiles_simple_1' not in result.stdout
+        assert 'multiplecomposefiles_another_1' not in result.stdout
+        assert 'multiplecomposefiles_yetanother_1' in result.stdout
 
     def test_pull(self):
         result = self.dispatch(['pull'])
@@ -528,13 +528,16 @@ class CLITestCase(DockerClientTestCase):
             returncode=1
         )
 
-        self.assertRegexpMatches(result.stderr, re.compile('^Pulling simple', re.MULTILINE))
-        self.assertRegexpMatches(result.stderr, re.compile('^Pulling another', re.MULTILINE))
-        self.assertRegexpMatches(result.stderr,
-                                 re.compile('^ERROR: for another .*does not exist.*', re.MULTILINE))
-        self.assertRegexpMatches(result.stderr,
-                                 re.compile('''^(ERROR: )?(b')?.* nonexisting-image''',
-                                            re.MULTILINE))
+        assert re.search(re.compile('^Pulling simple', re.MULTILINE), result.stderr)
+        assert re.search(re.compile('^Pulling another', re.MULTILINE), result.stderr)
+        assert re.search(
+            re.compile('^ERROR: for another .*does not exist.*', re.MULTILINE),
+            result.stderr
+        )
+        assert re.search(
+            re.compile('''^(ERROR: )?(b')?.* nonexisting-image''', re.MULTILINE),
+            result.stderr
+        )
 
     def test_build_plain(self):
         self.base_dir = 'tests/fixtures/simple-dockerfile'
@@ -573,7 +576,6 @@ class CLITestCase(DockerClientTestCase):
         assert BUILD_CACHE_TEXT not in result.stdout
         assert BUILD_PULL_TEXT in result.stdout
 
-    @pytest.mark.xfail(reason='17.10.0 RC bug remove after GA https://github.com/moby/moby/issues/35116')
     def test_build_failed(self):
         self.base_dir = 'tests/fixtures/simple-failing-dockerfile'
         self.dispatch(['build', 'simple'], returncode=1)
@@ -587,7 +589,6 @@ class CLITestCase(DockerClientTestCase):
         ]
         assert len(containers) == 1
 
-    @pytest.mark.xfail(reason='17.10.0 RC bug remove after GA https://github.com/moby/moby/issues/35116')
     def test_build_failed_forcerm(self):
         self.base_dir = 'tests/fixtures/simple-failing-dockerfile'
         self.dispatch(['build', '--force-rm', 'simple'], returncode=1)
@@ -809,36 +810,36 @@ class CLITestCase(DockerClientTestCase):
     def test_down_timeout(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
         ""
 
         self.dispatch(['down', '-t', '1'], None)
 
-        self.assertEqual(len(service.containers(stopped=True)), 0)
+        assert len(service.containers(stopped=True)) == 0
 
     def test_down_signal(self):
         self.base_dir = 'tests/fixtures/stop-signal-composefile'
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
 
         self.dispatch(['down', '-t', '1'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
+        assert len(service.containers(stopped=True)) == 0
 
     def test_up_detached(self):
         self.dispatch(['up', '-d'])
         service = self.project.get_service('simple')
         another = self.project.get_service('another')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertEqual(len(another.containers()), 1)
+        assert len(service.containers()) == 1
+        assert len(another.containers()) == 1
 
         # Ensure containers don't have stdin and stdout connected in -d mode
         container, = service.containers()
-        self.assertFalse(container.get('Config.AttachStderr'))
-        self.assertFalse(container.get('Config.AttachStdout'))
-        self.assertFalse(container.get('Config.AttachStdin'))
+        assert not container.get('Config.AttachStderr')
+        assert not container.get('Config.AttachStdout')
+        assert not container.get('Config.AttachStdin')
 
     def test_up_attached(self):
         self.base_dir = 'tests/fixtures/echo-services'
@@ -858,7 +859,7 @@ class CLITestCase(DockerClientTestCase):
 
         network_name = self.project.networks.networks['default'].full_name
         networks = self.client.networks(names=[network_name])
-        self.assertEqual(len(networks), 1)
+        assert len(networks) == 1
         assert networks[0]['Driver'] == 'bridge' if not is_cluster(self.client) else 'overlay'
         assert 'com.docker.network.bridge.enable_icc' not in networks[0]['Options']
 
@@ -866,17 +867,17 @@ class CLITestCase(DockerClientTestCase):
 
         for service in services:
             containers = service.containers()
-            self.assertEqual(len(containers), 1)
+            assert len(containers) == 1
 
             container = containers[0]
-            self.assertIn(container.id, network['Containers'])
+            assert container.id in network['Containers']
 
             networks = container.get('NetworkSettings.Networks')
-            self.assertEqual(list(networks), [network['Name']])
+            assert list(networks) == [network['Name']]
 
-            self.assertEqual(
-                sorted(networks[network['Name']]['Aliases']),
-                sorted([service.name, container.short_id]))
+            assert sorted(networks[network['Name']]['Aliases']) == sorted(
+                [service.name, container.short_id]
+            )
 
             for service in services:
                 assert self.lookup(container, service.name)
@@ -1213,13 +1214,13 @@ class CLITestCase(DockerClientTestCase):
         console = self.project.get_service('console')
 
         # console was not started
-        self.assertEqual(len(web.containers()), 1)
-        self.assertEqual(len(db.containers()), 1)
-        self.assertEqual(len(console.containers()), 0)
+        assert len(web.containers()) == 1
+        assert len(db.containers()) == 1
+        assert len(console.containers()) == 0
 
         # web has links
         web_container = web.containers()[0]
-        self.assertTrue(web_container.get('HostConfig.Links'))
+        assert web_container.get('HostConfig.Links')
 
     def test_up_with_net_is_invalid(self):
         self.base_dir = 'tests/fixtures/net-container'
@@ -1241,8 +1242,9 @@ class CLITestCase(DockerClientTestCase):
         foo = self.project.get_service('foo')
         foo_container = foo.containers()[0]
 
-        assert foo_container.get('HostConfig.NetworkMode') == \
-            'container:{}'.format(bar_container.id)
+        assert foo_container.get('HostConfig.NetworkMode') == 'container:{}'.format(
+            bar_container.id
+        )
 
     @v3_only()
     def test_up_with_healthcheck(self):
@@ -1294,37 +1296,37 @@ class CLITestCase(DockerClientTestCase):
         web = self.project.get_service('web')
         db = self.project.get_service('db')
         console = self.project.get_service('console')
-        self.assertEqual(len(web.containers()), 1)
-        self.assertEqual(len(db.containers()), 0)
-        self.assertEqual(len(console.containers()), 0)
+        assert len(web.containers()) == 1
+        assert len(db.containers()) == 0
+        assert len(console.containers()) == 0
 
     def test_up_with_force_recreate(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
+        assert len(service.containers()) == 1
 
         old_ids = [c.id for c in service.containers()]
 
         self.dispatch(['up', '-d', '--force-recreate'], None)
-        self.assertEqual(len(service.containers()), 1)
+        assert len(service.containers()) == 1
 
         new_ids = [c.id for c in service.containers()]
 
-        self.assertNotEqual(old_ids, new_ids)
+        assert old_ids != new_ids
 
     def test_up_with_no_recreate(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
+        assert len(service.containers()) == 1
 
         old_ids = [c.id for c in service.containers()]
 
         self.dispatch(['up', '-d', '--no-recreate'], None)
-        self.assertEqual(len(service.containers()), 1)
+        assert len(service.containers()) == 1
 
         new_ids = [c.id for c in service.containers()]
 
-        self.assertEqual(old_ids, new_ids)
+        assert old_ids == new_ids
 
     def test_up_with_force_recreate_and_no_recreate(self):
         self.dispatch(
@@ -1365,14 +1367,14 @@ class CLITestCase(DockerClientTestCase):
         proc = start_process(self.base_dir, ['up', '--abort-on-container-exit'])
         wait_on_condition(ContainerCountCondition(self.project, 0))
         proc.wait()
-        self.assertEqual(proc.returncode, 0)
+        assert proc.returncode == 0
 
     def test_up_handles_abort_on_container_exit_code(self):
         self.base_dir = 'tests/fixtures/abort-on-container-exit-1'
         proc = start_process(self.base_dir, ['up', '--abort-on-container-exit'])
         wait_on_condition(ContainerCountCondition(self.project, 0))
         proc.wait()
-        self.assertEqual(proc.returncode, 1)
+        assert proc.returncode == 1
 
     @v2_only()
     @no_cluster('Container PID mode does not work across clusters')
@@ -1403,27 +1405,27 @@ class CLITestCase(DockerClientTestCase):
     def test_exec_without_tty(self):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['up', '-d', 'console'])
-        self.assertEqual(len(self.project.containers()), 1)
+        assert len(self.project.containers()) == 1
 
         stdout, stderr = self.dispatch(['exec', '-T', 'console', 'ls', '-1d', '/'])
-        self.assertEqual(stderr, "")
-        self.assertEqual(stdout, "/\n")
+        assert stderr == ""
+        assert stdout == "/\n"
 
     def test_exec_custom_user(self):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['up', '-d', 'console'])
-        self.assertEqual(len(self.project.containers()), 1)
+        assert len(self.project.containers()) == 1
 
         stdout, stderr = self.dispatch(['exec', '-T', '--user=operator', 'console', 'whoami'])
-        self.assertEqual(stdout, "operator\n")
-        self.assertEqual(stderr, "")
+        assert stdout == "operator\n"
+        assert stderr == ""
 
     @v2_2_only()
     def test_exec_service_with_environment_overridden(self):
         name = 'service'
         self.base_dir = 'tests/fixtures/environment-exec'
         self.dispatch(['up', '-d'])
-        self.assertEqual(len(self.project.containers()), 1)
+        assert len(self.project.containers()) == 1
 
         stdout, stderr = self.dispatch([
             'exec',
@@ -1441,27 +1443,27 @@ class CLITestCase(DockerClientTestCase):
         # added option from command line
         assert 'alpha=beta' in stdout
 
-        self.assertEqual(stderr, '')
+        assert stderr == ''
 
     def test_run_service_without_links(self):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['run', 'console', '/bin/true'])
-        self.assertEqual(len(self.project.containers()), 0)
+        assert len(self.project.containers()) == 0
 
         # Ensure stdin/out was open
         container = self.project.containers(stopped=True, one_off=OneOffFilter.only)[0]
         config = container.inspect()['Config']
-        self.assertTrue(config['AttachStderr'])
-        self.assertTrue(config['AttachStdout'])
-        self.assertTrue(config['AttachStdin'])
+        assert config['AttachStderr']
+        assert config['AttachStdout']
+        assert config['AttachStdin']
 
     def test_run_service_with_links(self):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['run', 'web', '/bin/true'], None)
         db = self.project.get_service('db')
         console = self.project.get_service('console')
-        self.assertEqual(len(db.containers()), 1)
-        self.assertEqual(len(console.containers()), 0)
+        assert len(db.containers()) == 1
+        assert len(console.containers()) == 0
 
     @v2_only()
     def test_run_service_with_dependencies(self):
@@ -1469,8 +1471,8 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', 'web', '/bin/true'], None)
         db = self.project.get_service('db')
         console = self.project.get_service('console')
-        self.assertEqual(len(db.containers()), 1)
-        self.assertEqual(len(console.containers()), 0)
+        assert len(db.containers()) == 1
+        assert len(console.containers()) == 0
 
     def test_run_service_with_scaled_dependencies(self):
         self.base_dir = 'tests/fixtures/v2-dependencies'
@@ -1487,22 +1489,22 @@ class CLITestCase(DockerClientTestCase):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['run', '--no-deps', 'web', '/bin/true'])
         db = self.project.get_service('db')
-        self.assertEqual(len(db.containers()), 0)
+        assert len(db.containers()) == 0
 
     def test_run_does_not_recreate_linked_containers(self):
         self.base_dir = 'tests/fixtures/links-composefile'
         self.dispatch(['up', '-d', 'db'])
         db = self.project.get_service('db')
-        self.assertEqual(len(db.containers()), 1)
+        assert len(db.containers()) == 1
 
         old_ids = [c.id for c in db.containers()]
 
         self.dispatch(['run', 'web', '/bin/true'], None)
-        self.assertEqual(len(db.containers()), 1)
+        assert len(db.containers()) == 1
 
         new_ids = [c.id for c in db.containers()]
 
-        self.assertEqual(old_ids, new_ids)
+        assert old_ids == new_ids
 
     def test_run_without_command(self):
         self.base_dir = 'tests/fixtures/commands-composefile'
@@ -1511,18 +1513,12 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', 'implicit'])
         service = self.project.get_service('implicit')
         containers = service.containers(stopped=True, one_off=OneOffFilter.only)
-        self.assertEqual(
-            [c.human_readable_command for c in containers],
-            [u'/bin/sh -c echo "success"'],
-        )
+        assert [c.human_readable_command for c in containers] == [u'/bin/sh -c echo "success"']
 
         self.dispatch(['run', 'explicit'])
         service = self.project.get_service('explicit')
         containers = service.containers(stopped=True, one_off=OneOffFilter.only)
-        self.assertEqual(
-            [c.human_readable_command for c in containers],
-            [u'/bin/true'],
-        )
+        assert [c.human_readable_command for c in containers] == [u'/bin/true']
 
     @pytest.mark.skipif(SWARM_SKIP_RM_VOLUMES, reason='Swarm DELETE /containers/<id> bug')
     def test_run_rm(self):
@@ -1534,7 +1530,7 @@ class CLITestCase(DockerClientTestCase):
             'running'))
         service = self.project.get_service('test')
         containers = service.containers(one_off=OneOffFilter.only)
-        self.assertEqual(len(containers), 1)
+        assert len(containers) == 1
         mounts = containers[0].get('Mounts')
         for mount in mounts:
             if mount['Destination'] == '/container-path':
@@ -1543,7 +1539,7 @@ class CLITestCase(DockerClientTestCase):
         os.kill(proc.pid, signal.SIGINT)
         wait_on_process(proc, 1)
 
-        self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+        assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
 
         volumes = self.client.volumes()['Volumes']
         assert volumes is not None
@@ -1611,7 +1607,7 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', '--user={user}'.format(user=user), name], returncode=1)
         service = self.project.get_service(name)
         container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
-        self.assertEqual(user, container.get('Config.User'))
+        assert user == container.get('Config.User')
 
     def test_run_service_with_user_overridden_short_form(self):
         self.base_dir = 'tests/fixtures/user-composefile'
@@ -1620,7 +1616,7 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', '-u', user, name], returncode=1)
         service = self.project.get_service(name)
         container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
-        self.assertEqual(user, container.get('Config.User'))
+        assert user == container.get('Config.User')
 
     def test_run_service_with_environment_overridden(self):
         name = 'service'
@@ -1635,13 +1631,13 @@ class CLITestCase(DockerClientTestCase):
         service = self.project.get_service(name)
         container = service.containers(stopped=True, one_off=OneOffFilter.only)[0]
         # env overridden
-        self.assertEqual('notbar', container.environment['foo'])
+        assert 'notbar' == container.environment['foo']
         # keep environment from yaml
-        self.assertEqual('world', container.environment['hello'])
+        assert 'world' == container.environment['hello']
         # added option from command line
-        self.assertEqual('beta', container.environment['alpha'])
+        assert 'beta' == container.environment['alpha']
         # make sure a value with a = don't crash out
-        self.assertEqual('moto=bobo', container.environment['allo'])
+        assert 'moto=bobo' == container.environment['allo']
 
     def test_run_service_without_map_ports(self):
         # create one off container
@@ -1657,8 +1653,8 @@ class CLITestCase(DockerClientTestCase):
         container.stop()
 
         # check the ports
-        self.assertEqual(port_random, None)
-        self.assertEqual(port_assigned, None)
+        assert port_random is None
+        assert port_assigned is None
 
     def test_run_service_with_map_ports(self):
         # create one off container
@@ -1716,8 +1712,8 @@ class CLITestCase(DockerClientTestCase):
         container.stop()
 
         # check the ports
-        self.assertEqual(port_short, "127.0.0.1:30000")
-        self.assertEqual(port_full, "127.0.0.1:30001")
+        assert port_short == "127.0.0.1:30000"
+        assert port_full == "127.0.0.1:30001"
 
     def test_run_with_expose_ports(self):
         # create one off container
@@ -1726,7 +1722,7 @@ class CLITestCase(DockerClientTestCase):
         container = self.project.get_service('simple').containers(one_off=OneOffFilter.only)[0]
 
         ports = container.ports
-        self.assertEqual(len(ports), 9)
+        assert len(ports) == 9
         # exposed ports are not mapped to host ports
         assert ports['3000/tcp'] is None
         assert ports['3001/tcp'] is None
@@ -1748,7 +1744,7 @@ class CLITestCase(DockerClientTestCase):
 
         service = self.project.get_service('service')
         container, = service.containers(stopped=True, one_off=OneOffFilter.only)
-        self.assertEqual(container.name, name)
+        assert container.name == name
 
     def test_run_service_with_workdir_overridden(self):
         self.base_dir = 'tests/fixtures/run-workdir'
@@ -1757,7 +1753,7 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', '--workdir={workdir}'.format(workdir=workdir), name])
         service = self.project.get_service(name)
         container = service.containers(stopped=True, one_off=True)[0]
-        self.assertEqual(workdir, container.get('Config.WorkingDir'))
+        assert workdir == container.get('Config.WorkingDir')
 
     def test_run_service_with_workdir_overridden_short_form(self):
         self.base_dir = 'tests/fixtures/run-workdir'
@@ -1766,7 +1762,7 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['run', '-w', workdir, name])
         service = self.project.get_service(name)
         container = service.containers(stopped=True, one_off=True)[0]
-        self.assertEqual(workdir, container.get('Config.WorkingDir'))
+        assert workdir == container.get('Config.WorkingDir')
 
     @v2_only()
     def test_run_interactive_connects_to_network(self):
@@ -1887,19 +1883,19 @@ class CLITestCase(DockerClientTestCase):
         service = self.project.get_service('simple')
         service.create_container()
         kill_service(service)
-        self.assertEqual(len(service.containers(stopped=True)), 1)
+        assert len(service.containers(stopped=True)) == 1
         self.dispatch(['rm', '--force'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
+        assert len(service.containers(stopped=True)) == 0
         service = self.project.get_service('simple')
         service.create_container()
         kill_service(service)
-        self.assertEqual(len(service.containers(stopped=True)), 1)
+        assert len(service.containers(stopped=True)) == 1
         self.dispatch(['rm', '-f'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
+        assert len(service.containers(stopped=True)) == 0
         service = self.project.get_service('simple')
         service.create_container()
         self.dispatch(['rm', '-fs'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
+        assert len(service.containers(stopped=True)) == 0
 
     def test_rm_stop(self):
         self.dispatch(['up', '-d'], None)
@@ -1923,43 +1919,43 @@ class CLITestCase(DockerClientTestCase):
         service.create_container(one_off=False)
         service.create_container(one_off=True)
         kill_service(service)
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 1)
+        assert len(service.containers(stopped=True)) == 1
+        assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 1
         self.dispatch(['rm', '-f'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
-        self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+        assert len(service.containers(stopped=True)) == 0
+        assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
 
         service.create_container(one_off=False)
         service.create_container(one_off=True)
         kill_service(service)
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 1)
+        assert len(service.containers(stopped=True)) == 1
+        assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 1
         self.dispatch(['rm', '-f', '--all'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 0)
-        self.assertEqual(len(service.containers(stopped=True, one_off=OneOffFilter.only)), 0)
+        assert len(service.containers(stopped=True)) == 0
+        assert len(service.containers(stopped=True, one_off=OneOffFilter.only)) == 0
 
     def test_stop(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
 
         self.dispatch(['stop', '-t', '1'], None)
 
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertFalse(service.containers(stopped=True)[0].is_running)
+        assert len(service.containers(stopped=True)) == 1
+        assert not service.containers(stopped=True)[0].is_running
 
     def test_stop_signal(self):
         self.base_dir = 'tests/fixtures/stop-signal-composefile'
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
 
         self.dispatch(['stop', '-t', '1'], None)
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertFalse(service.containers(stopped=True)[0].is_running)
-        self.assertEqual(service.containers(stopped=True)[0].exit_code, 0)
+        assert len(service.containers(stopped=True)) == 1
+        assert not service.containers(stopped=True)[0].is_running
+        assert service.containers(stopped=True)[0].exit_code == 0
 
     def test_start_no_containers(self):
         result = self.dispatch(['start'], returncode=1)
@@ -1971,39 +1967,39 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'])
         simple = self.project.get_service('simple').containers()[0]
         log_config = simple.get('HostConfig.LogConfig')
-        self.assertTrue(log_config)
-        self.assertEqual(log_config.get('Type'), 'none')
+        assert log_config
+        assert log_config.get('Type') == 'none'
 
         another = self.project.get_service('another').containers()[0]
         log_config = another.get('HostConfig.LogConfig')
-        self.assertTrue(log_config)
-        self.assertEqual(log_config.get('Type'), 'json-file')
-        self.assertEqual(log_config.get('Config')['max-size'], '10m')
+        assert log_config
+        assert log_config.get('Type') == 'json-file'
+        assert log_config.get('Config')['max-size'] == '10m'
 
     def test_up_logging_legacy(self):
         self.base_dir = 'tests/fixtures/logging-composefile-legacy'
         self.dispatch(['up', '-d'])
         simple = self.project.get_service('simple').containers()[0]
         log_config = simple.get('HostConfig.LogConfig')
-        self.assertTrue(log_config)
-        self.assertEqual(log_config.get('Type'), 'none')
+        assert log_config
+        assert log_config.get('Type') == 'none'
 
         another = self.project.get_service('another').containers()[0]
         log_config = another.get('HostConfig.LogConfig')
-        self.assertTrue(log_config)
-        self.assertEqual(log_config.get('Type'), 'json-file')
-        self.assertEqual(log_config.get('Config')['max-size'], '10m')
+        assert log_config
+        assert log_config.get('Type') == 'json-file'
+        assert log_config.get('Config')['max-size'] == '10m'
 
     def test_pause_unpause(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertFalse(service.containers()[0].is_paused)
+        assert not service.containers()[0].is_paused
 
         self.dispatch(['pause'], None)
-        self.assertTrue(service.containers()[0].is_paused)
+        assert service.containers()[0].is_paused
 
         self.dispatch(['unpause'], None)
-        self.assertFalse(service.containers()[0].is_paused)
+        assert not service.containers()[0].is_paused
 
     def test_pause_no_containers(self):
         result = self.dispatch(['pause'], returncode=1)
@@ -2077,7 +2073,7 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'])
 
         result = self.dispatch(['logs', '-f', '-t'])
-        self.assertRegexpMatches(result.stdout, '(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})')
+        assert re.search('(\d{4})-(\d{2})-(\d{2})T(\d{2})\:(\d{2})\:(\d{2})', result.stdout)
 
     def test_logs_tail(self):
         self.base_dir = 'tests/fixtures/logs-tail-composefile'
@@ -2092,36 +2088,36 @@ class CLITestCase(DockerClientTestCase):
     def test_kill(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
 
         self.dispatch(['kill'], None)
 
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertFalse(service.containers(stopped=True)[0].is_running)
+        assert len(service.containers(stopped=True)) == 1
+        assert not service.containers(stopped=True)[0].is_running
 
     def test_kill_signal_sigstop(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
-        self.assertEqual(len(service.containers()), 1)
-        self.assertTrue(service.containers()[0].is_running)
+        assert len(service.containers()) == 1
+        assert service.containers()[0].is_running
 
         self.dispatch(['kill', '-s', 'SIGSTOP'], None)
 
-        self.assertEqual(len(service.containers()), 1)
+        assert len(service.containers()) == 1
         # The container is still running. It has only been paused
-        self.assertTrue(service.containers()[0].is_running)
+        assert service.containers()[0].is_running
 
     def test_kill_stopped_service(self):
         self.dispatch(['up', '-d'], None)
         service = self.project.get_service('simple')
         self.dispatch(['kill', '-s', 'SIGSTOP'], None)
-        self.assertTrue(service.containers()[0].is_running)
+        assert service.containers()[0].is_running
 
         self.dispatch(['kill', '-s', 'SIGKILL'], None)
 
-        self.assertEqual(len(service.containers(stopped=True)), 1)
-        self.assertFalse(service.containers(stopped=True)[0].is_running)
+        assert len(service.containers(stopped=True)) == 1
+        assert not service.containers(stopped=True)[0].is_running
 
     def test_restart(self):
         service = self.project.get_service('simple')
@@ -2130,23 +2126,17 @@ class CLITestCase(DockerClientTestCase):
         started_at = container.dictionary['State']['StartedAt']
         self.dispatch(['restart', '-t', '1'], None)
         container.inspect()
-        self.assertNotEqual(
-            container.dictionary['State']['FinishedAt'],
-            '0001-01-01T00:00:00Z',
-        )
-        self.assertNotEqual(
-            container.dictionary['State']['StartedAt'],
-            started_at,
-        )
+        assert container.dictionary['State']['FinishedAt'] != '0001-01-01T00:00:00Z'
+        assert container.dictionary['State']['StartedAt'] != started_at
 
     def test_restart_stopped_container(self):
         service = self.project.get_service('simple')
         container = service.create_container()
         container.start()
         container.kill()
-        self.assertEqual(len(service.containers(stopped=True)), 1)
+        assert len(service.containers(stopped=True)) == 1
         self.dispatch(['restart', '-t', '1'], None)
-        self.assertEqual(len(service.containers(stopped=False)), 1)
+        assert len(service.containers(stopped=False)) == 1
 
     def test_restart_no_containers(self):
         result = self.dispatch(['restart'], returncode=1)
@@ -2156,23 +2146,23 @@ class CLITestCase(DockerClientTestCase):
         project = self.project
 
         self.dispatch(['scale', 'simple=1'])
-        self.assertEqual(len(project.get_service('simple').containers()), 1)
+        assert len(project.get_service('simple').containers()) == 1
 
         self.dispatch(['scale', 'simple=3', 'another=2'])
-        self.assertEqual(len(project.get_service('simple').containers()), 3)
-        self.assertEqual(len(project.get_service('another').containers()), 2)
+        assert len(project.get_service('simple').containers()) == 3
+        assert len(project.get_service('another').containers()) == 2
 
         self.dispatch(['scale', 'simple=1', 'another=1'])
-        self.assertEqual(len(project.get_service('simple').containers()), 1)
-        self.assertEqual(len(project.get_service('another').containers()), 1)
+        assert len(project.get_service('simple').containers()) == 1
+        assert len(project.get_service('another').containers()) == 1
 
         self.dispatch(['scale', 'simple=1', 'another=1'])
-        self.assertEqual(len(project.get_service('simple').containers()), 1)
-        self.assertEqual(len(project.get_service('another').containers()), 1)
+        assert len(project.get_service('simple').containers()) == 1
+        assert len(project.get_service('another').containers()) == 1
 
         self.dispatch(['scale', 'simple=0', 'another=0'])
-        self.assertEqual(len(project.get_service('simple').containers()), 0)
-        self.assertEqual(len(project.get_service('another').containers()), 0)
+        assert len(project.get_service('simple').containers()) == 0
+        assert len(project.get_service('another').containers()) == 0
 
     def test_scale_v2_2(self):
         self.base_dir = 'tests/fixtures/scale'
@@ -2267,10 +2257,10 @@ class CLITestCase(DockerClientTestCase):
                 result = self.dispatch(['port', '--index=' + str(index), 'simple', str(number)])
             return result.stdout.rstrip()
 
-        self.assertEqual(get_port(3000), containers[0].get_local_port(3000))
-        self.assertEqual(get_port(3000, index=1), containers[0].get_local_port(3000))
-        self.assertEqual(get_port(3000, index=2), containers[1].get_local_port(3000))
-        self.assertEqual(get_port(3002), "")
+        assert get_port(3000) == containers[0].get_local_port(3000)
+        assert get_port(3000, index=1) == containers[0].get_local_port(3000)
+        assert get_port(3000, index=2) == containers[1].get_local_port(3000)
+        assert get_port(3002) == ""
 
     def test_events_json(self):
         events_proc = start_process(self.base_dir, ['events', '--json'])
@@ -2321,8 +2311,8 @@ class CLITestCase(DockerClientTestCase):
         self._project = get_project(self.base_dir, [config_path])
 
         containers = self.project.containers(stopped=True)
-        self.assertEqual(len(containers), 1)
-        self.assertIn("FOO=1", containers[0].get('Config.Env'))
+        assert len(containers) == 1
+        assert "FOO=1" in containers[0].get('Config.Env')
 
     @mock.patch.dict(os.environ)
     def test_home_and_env_var_in_volume_path(self):
@@ -2342,11 +2332,11 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'], None)
 
         containers = self.project.containers()
-        self.assertEqual(len(containers), 2)
+        assert len(containers) == 2
 
         web, db = containers
-        self.assertEqual(web.human_readable_command, 'top')
-        self.assertEqual(db.human_readable_command, 'top')
+        assert web.human_readable_command == 'top'
+        assert db.human_readable_command == 'top'
 
     def test_up_with_multiple_files(self):
         self.base_dir = 'tests/fixtures/override-files'
@@ -2366,21 +2356,18 @@ class CLITestCase(DockerClientTestCase):
             None)
 
         containers = self.project.containers()
-        self.assertEqual(len(containers), 3)
+        assert len(containers) == 3
 
         web, other, db = containers
-        self.assertEqual(web.human_readable_command, 'top')
-        self.assertEqual(db.human_readable_command, 'top')
-        self.assertEqual(other.human_readable_command, 'top')
+        assert web.human_readable_command == 'top'
+        assert db.human_readable_command == 'top'
+        assert other.human_readable_command == 'top'
 
     def test_up_with_extends(self):
         self.base_dir = 'tests/fixtures/extends'
         self.dispatch(['up', '-d'], None)
 
-        self.assertEqual(
-            set([s.name for s in self.project.services]),
-            set(['mydb', 'myweb']),
-        )
+        assert set([s.name for s in self.project.services]) == set(['mydb', 'myweb'])
 
         # Sort by name so we get [db, web]
         containers = sorted(
@@ -2388,19 +2375,17 @@ class CLITestCase(DockerClientTestCase):
             key=lambda c: c.name,
         )
 
-        self.assertEqual(len(containers), 2)
+        assert len(containers) == 2
         web = containers[1]
 
-        self.assertEqual(
-            set(get_links(web)),
-            set(['db', 'mydb_1', 'extends_mydb_1']))
+        assert set(get_links(web)) == set(['db', 'mydb_1', 'extends_mydb_1'])
 
         expected_env = set([
             "FOO=1",
             "BAR=2",
             "BAZ=2",
         ])
-        self.assertTrue(expected_env <= set(web.get('Config.Env')))
+        assert expected_env <= set(web.get('Config.Env'))
 
     def test_top_services_not_running(self):
         self.base_dir = 'tests/fixtures/top'
@@ -2412,9 +2397,9 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'])
         result = self.dispatch(['top'])
 
-        self.assertIn('top_service_a', result.stdout)
-        self.assertIn('top_service_b', result.stdout)
-        self.assertNotIn('top_not_a_service', result.stdout)
+        assert 'top_service_a' in result.stdout
+        assert 'top_service_b' in result.stdout
+        assert 'top_not_a_service' not in result.stdout
 
     def test_top_processes_running(self):
         self.base_dir = 'tests/fixtures/top'
@@ -2473,14 +2458,14 @@ class CLITestCase(DockerClientTestCase):
         self.dispatch(['up', '-d'], None)
 
         containers = self.project.containers()
-        self.assertEqual(len(containers), 2)
+        assert len(containers) == 2
 
         web, db = containers
-        self.assertEqual(web.human_readable_command, 'sleep 100')
-        self.assertEqual(db.human_readable_command, 'top')
+        assert web.human_readable_command == 'sleep 100'
+        assert db.human_readable_command == 'top'
 
     def test_up_with_duplicate_override_yaml_files(self):
         self.base_dir = 'tests/fixtures/duplicate-override-yaml-files'
-        with self.assertRaises(DuplicateOverrideFileFound):
+        with pytest.raises(DuplicateOverrideFileFound):
             get_project(self.base_dir, [])
         self.base_dir = None

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]))
+        assert 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]))
+        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'])
-        self.assertEqual(
-            set([c.name for c in project.containers() if c.is_paused]),
-            set([web_container_1.name, web_container_2.name]))
+        assert 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]))
+        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'])
-        self.assertEqual(len([c.name for c in project.containers() if c.is_paused]), 2)
+        assert 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)
+        assert 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([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()

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

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

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

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

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

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,

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

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'

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

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(

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

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