Use pytest assertspytest-asserts

Signed-off-by: Joffrey F <joffrey@docker.com>

14 files changed, 392 insertions, 413 deletions

diff --git a/tests/integration/api_build_test.py b/tests/integration/api_build_test.py
index 245214e..ee9b68a 100644
--- a/tests/integration/api_build_test.py
+++ b/tests/integration/api_build_test.py
@@ -43,7 +43,7 @@ class BuildTest(BaseAPIIntegrationTest):
             if six.PY3:
                 chunk = chunk.decode('utf-8')
             logs += chunk
-        self.assertNotEqual(logs, '')
+        assert logs != ''
 
     @requires_api_version('1.8')
     def test_build_with_dockerignore(self):
@@ -92,11 +92,10 @@ class BuildTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
 
-        self.assertEqual(
-            sorted(list(filter(None, logs.split('\n')))),
-            sorted(['/test/ignored/subdir/excepted-file',
-                    '/test/not-ignored']),
-        )
+        assert sorted(list(filter(None, logs.split('\n')))) == sorted([
+            '/test/ignored/subdir/excepted-file',
+            '/test/not-ignored'
+        ])
 
     @requires_api_version('1.21')
     def test_build_with_buildargs(self):
@@ -114,7 +113,7 @@ class BuildTest(BaseAPIIntegrationTest):
             pass
 
         info = self.client.inspect_image('buildargs')
-        self.assertEqual(info['Config']['User'], 'OK')
+        assert info['Config']['User'] == 'OK'
 
     @requires_api_version('1.22')
     def test_build_shmsize(self):
@@ -152,7 +151,7 @@ class BuildTest(BaseAPIIntegrationTest):
             pass
 
         info = self.client.inspect_image('labels')
-        self.assertEqual(info['Config']['Labels'], labels)
+        assert info['Config']['Labels'] == labels
 
     @requires_api_version('1.25')
     def test_build_with_cache_from(self):
@@ -309,8 +308,8 @@ class BuildTest(BaseAPIIntegrationTest):
 
         non_squashed = build_squashed(False)
         squashed = build_squashed(True)
-        self.assertEqual(len(non_squashed['RootFS']['Layers']), 4)
-        self.assertEqual(len(squashed['RootFS']['Layers']), 2)
+        assert len(non_squashed['RootFS']['Layers']) == 4
+        assert len(squashed['RootFS']['Layers']) == 2
 
     def test_build_stderr_data(self):
         control_chars = ['\x1b[91m', '\x1b[0m']
@@ -329,7 +328,7 @@ class BuildTest(BaseAPIIntegrationTest):
         expected = '{0}{2}\n{1}'.format(
             control_chars[0], control_chars[1], snippet
         )
-        self.assertTrue(any([line == expected for line in lines]))
+        assert any([line == expected for line in lines])
 
     def test_build_gzip_encoding(self):
         base_dir = tempfile.mkdtemp()
@@ -375,7 +374,7 @@ class BuildTest(BaseAPIIntegrationTest):
         assert 'Successfully built' in lines[-1]['stream']
 
     def test_build_gzip_custom_encoding(self):
-        with self.assertRaises(errors.DockerException):
+        with pytest.raises(errors.DockerException):
             self.client.build(path='.', gzip=True, encoding='text/html')
 
     @requires_api_version('1.32')
diff --git a/tests/integration/api_client_test.py b/tests/integration/api_client_test.py
index cfb45a3..05281f8 100644
--- a/tests/integration/api_client_test.py
+++ b/tests/integration/api_client_test.py
@@ -14,14 +14,14 @@ from .base import BaseAPIIntegrationTest
 class InformationTest(BaseAPIIntegrationTest):
     def test_version(self):
         res = self.client.version()
-        self.assertIn('GoVersion', res)
-        self.assertIn('Version', res)
+        assert 'GoVersion' in res
+        assert 'Version' in res
 
     def test_info(self):
         res = self.client.info()
-        self.assertIn('Containers', res)
-        self.assertIn('Images', res)
-        self.assertIn('Debug', res)
+        assert 'Containers' in res
+        assert 'Images' in res
+        assert 'Debug' in res
 
 
 class LoadConfigTest(BaseAPIIntegrationTest):
@@ -35,12 +35,12 @@ class LoadConfigTest(BaseAPIIntegrationTest):
         f.write('email = sakuya@scarlet.net')
         f.close()
         cfg = docker.auth.load_config(cfg_path)
-        self.assertNotEqual(cfg[docker.auth.INDEX_NAME], None)
+        assert cfg[docker.auth.INDEX_NAME] is not None
         cfg = cfg[docker.auth.INDEX_NAME]
-        self.assertEqual(cfg['username'], 'sakuya')
-        self.assertEqual(cfg['password'], 'izayoi')
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
-        self.assertEqual(cfg.get('Auth'), None)
+        assert cfg['username'] == 'sakuya'
+        assert cfg['password'] == 'izayoi'
+        assert cfg['email'] == 'sakuya@scarlet.net'
+        assert cfg.get('Auth') is None
 
     def test_load_json_config(self):
         folder = tempfile.mkdtemp()
@@ -53,12 +53,12 @@ class LoadConfigTest(BaseAPIIntegrationTest):
             docker.auth.INDEX_URL, auth_, email_))
         f.close()
         cfg = docker.auth.load_config(cfg_path)
-        self.assertNotEqual(cfg[docker.auth.INDEX_URL], None)
+        assert cfg[docker.auth.INDEX_URL] is not None
         cfg = cfg[docker.auth.INDEX_URL]
-        self.assertEqual(cfg['username'], 'sakuya')
-        self.assertEqual(cfg['password'], 'izayoi')
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
-        self.assertEqual(cfg.get('Auth'), None)
+        assert cfg['username'] == 'sakuya'
+        assert cfg['password'] == 'izayoi'
+        assert cfg['email'] == 'sakuya@scarlet.net'
+        assert cfg.get('Auth') is None
 
 
 class AutoDetectVersionTest(unittest.TestCase):
@@ -66,9 +66,9 @@ class AutoDetectVersionTest(unittest.TestCase):
         client = docker.APIClient(version='auto', **kwargs_from_env())
         client_version = client._version
         api_version = client.version(api_version=False)['ApiVersion']
-        self.assertEqual(client_version, api_version)
+        assert client_version == api_version
         api_version_2 = client.version()['ApiVersion']
-        self.assertEqual(client_version, api_version_2)
+        assert client_version == api_version_2
         client.close()
 
 
@@ -90,8 +90,8 @@ class ConnectionTimeoutTest(unittest.TestCase):
         except:
             pass
         end = time.time()
-        self.assertTrue(res is None)
-        self.assertTrue(end - start < 2 * self.timeout)
+        assert res is None
+        assert end - start < 2 * self.timeout
 
 
 class UnixconnTest(unittest.TestCase):
@@ -112,5 +112,6 @@ class UnixconnTest(unittest.TestCase):
             client.close()
             del client
 
-            assert len(w) == 0, \
-                "No warnings produced: {0}".format(w[0].message)
+            assert len(w) == 0, "No warnings produced: {0}".format(
+                w[0].message
+            )
diff --git a/tests/integration/api_container_test.py b/tests/integration/api_container_test.py
index 5d06bc4..4585c44 100644
--- a/tests/integration/api_container_test.py
+++ b/tests/integration/api_container_test.py
@@ -16,6 +16,7 @@ import six
 from .base import BUSYBOX, BaseAPIIntegrationTest
 from .. import helpers
 from ..helpers import requires_api_version
+import re
 
 
 class ListContainersTest(BaseAPIIntegrationTest):
@@ -23,26 +24,26 @@ class ListContainersTest(BaseAPIIntegrationTest):
         res0 = self.client.containers(all=True)
         size = len(res0)
         res1 = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res1)
+        assert 'Id' in res1
         self.client.start(res1['Id'])
         self.tmp_containers.append(res1['Id'])
         res2 = self.client.containers(all=True)
-        self.assertEqual(size + 1, len(res2))
+        assert size + 1 == len(res2)
         retrieved = [x for x in res2 if x['Id'].startswith(res1['Id'])]
-        self.assertEqual(len(retrieved), 1)
+        assert len(retrieved) == 1
         retrieved = retrieved[0]
-        self.assertIn('Command', retrieved)
-        self.assertEqual(retrieved['Command'], six.text_type('true'))
-        self.assertIn('Image', retrieved)
-        self.assertRegex(retrieved['Image'], r'busybox:.*')
-        self.assertIn('Status', retrieved)
+        assert 'Command' in retrieved
+        assert retrieved['Command'] == six.text_type('true')
+        assert 'Image' in retrieved
+        assert re.search(r'busybox:.*', retrieved['Image'])
+        assert 'Status' in retrieved
 
 
 class CreateContainerTest(BaseAPIIntegrationTest):
 
     def test_create(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
 
     def test_create_with_host_pid_mode(self):
@@ -51,14 +52,14 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 pid_mode='host', network_mode='none'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
-        self.assertIn('PidMode', host_config)
-        self.assertEqual(host_config['PidMode'], 'host')
+        assert 'PidMode' in host_config
+        assert host_config['PidMode'] == 'host'
 
     def test_create_with_links(self):
         res0 = self.client.create_container(
@@ -99,15 +100,15 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         container3_id = res2['Id']
         self.tmp_containers.append(container3_id)
         self.client.start(container3_id)
-        self.assertEqual(self.client.wait(container3_id), 0)
+        assert self.client.wait(container3_id) == 0
 
         logs = self.client.logs(container3_id)
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn('{0}_NAME='.format(link_env_prefix1), logs)
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix1), logs)
-        self.assertIn('{0}_NAME='.format(link_env_prefix2), logs)
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix2), logs)
+        assert '{0}_NAME='.format(link_env_prefix1) in logs
+        assert '{0}_ENV_FOO=1'.format(link_env_prefix1) in logs
+        assert '{0}_NAME='.format(link_env_prefix2) in logs
+        assert '{0}_ENV_FOO=1'.format(link_env_prefix2) in logs
 
     def test_create_with_restart_policy(self):
         container = self.client.create_container(
@@ -120,12 +121,10 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         id = container['Id']
         self.client.start(id)
         self.client.wait(id)
-        with self.assertRaises(docker.errors.APIError) as exc:
+        with pytest.raises(docker.errors.APIError) as exc:
             self.client.remove_container(id)
-        err = exc.exception.explanation
-        self.assertIn(
-            'You cannot remove ', err
-        )
+        err = exc.value.explanation
+        assert 'You cannot remove ' in err
         self.client.remove_container(id, force=True)
 
     def test_create_container_with_volumes_from(self):
@@ -144,7 +143,7 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         container2_id = res1['Id']
         self.tmp_containers.append(container2_id)
         self.client.start(container2_id)
-        with self.assertRaises(docker.errors.DockerException):
+        with pytest.raises(docker.errors.DockerException):
             self.client.create_container(
                 BUSYBOX, 'cat', detach=True, stdin_open=True,
                 volumes_from=vol_names
@@ -169,19 +168,19 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 read_only=True, network_mode='none'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         res = self.client.wait(ctnr)
-        self.assertNotEqual(res, 0)
+        assert res != 0
 
     def create_container_with_name(self):
         res = self.client.create_container(BUSYBOX, 'true', name='foobar')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Name', inspect)
-        self.assertEqual('/foobar', inspect['Name'])
+        assert 'Name' in inspect
+        assert '/foobar' == inspect['Name']
 
     def create_container_privileged(self):
         res = self.client.create_container(
@@ -189,24 +188,24 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 privileged=True, network_mode='none'
             )
         )
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
         # Since Nov 2013, the Privileged flag is no longer part of the
         # container's config exposed via the API (safety concerns?).
         #
         if 'Privileged' in inspect['Config']:
-            self.assertEqual(inspect['Config']['Privileged'], True)
+            assert inspect['Config']['Privileged'] is True
 
     def test_create_with_mac_address(self):
         mac_address_expected = "02:42:ac:11:00:0a"
@@ -217,8 +216,7 @@ class CreateContainerTest(BaseAPIIntegrationTest):
 
         self.client.start(container)
         res = self.client.inspect_container(container['Id'])
-        self.assertEqual(mac_address_expected,
-                         res['NetworkSettings']['MacAddress'])
+        assert mac_address_expected == res['NetworkSettings']['MacAddress']
 
         self.client.kill(id)
 
@@ -236,8 +234,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
         groups = logs.strip().split(' ')
-        self.assertIn('1000', groups)
-        self.assertIn('1001', groups)
+        assert '1000' in groups
+        assert '1001' in groups
 
     @requires_api_version('1.20')
     def test_group_id_strings(self):
@@ -255,8 +253,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
             logs = logs.decode('utf-8')
 
         groups = logs.strip().split(' ')
-        self.assertIn('1000', groups)
-        self.assertIn('1001', groups)
+        assert '1000' in groups
+        assert '1001' in groups
 
     def test_valid_log_driver_and_log_opt(self):
         log_config = docker.types.LogConfig(
@@ -274,8 +272,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], log_config.type)
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        assert container_log_config['Type'] == log_config.type
+        assert container_log_config['Config'] == log_config.config
 
     def test_invalid_log_driver_raises_exception(self):
         log_config = docker.types.LogConfig(
@@ -311,8 +309,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], "json-file")
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        assert container_log_config['Type'] == "json-file"
+        assert container_log_config['Config'] == log_config.config
 
     def test_valid_no_config_specified(self):
         log_config = docker.types.LogConfig(
@@ -330,8 +328,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], "json-file")
-        self.assertEqual(container_log_config['Config'], {})
+        assert container_log_config['Type'] == "json-file"
+        assert container_log_config['Config'] == {}
 
     def test_create_with_memory_constraints_with_str(self):
         ctnr = self.client.create_container(
@@ -341,29 +339,29 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 mem_limit='700M'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
 
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
         for limit in ['Memory', 'MemorySwap']:
-            self.assertIn(limit, host_config)
+            assert limit in host_config
 
     def test_create_with_memory_constraints_with_int(self):
         ctnr = self.client.create_container(
             BUSYBOX, 'true',
             host_config=self.client.create_host_config(mem_swappiness=40)
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
 
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
-        self.assertIn('MemorySwappiness', host_config)
+        assert 'MemorySwappiness' in host_config
 
     def test_create_with_environment_variable_no_value(self):
         container = self.client.create_container(
@@ -511,7 +509,7 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn(self.filename, logs)
+        assert self.filename in logs
         inspect_data = self.client.inspect_container(container)
         self.check_container_data(inspect_data, True)
 
@@ -533,7 +531,7 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn(self.filename, logs)
+        assert self.filename in logs
 
         inspect_data = self.client.inspect_container(container)
         self.check_container_data(inspect_data, False)
@@ -605,23 +603,23 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
     def check_container_data(self, inspect_data, rw):
         if docker.utils.compare_version('1.20', self.client._version) < 0:
-            self.assertIn('Volumes', inspect_data)
-            self.assertIn(self.mount_dest, inspect_data['Volumes'])
-            self.assertEqual(
-                self.mount_origin, inspect_data['Volumes'][self.mount_dest]
+            assert 'Volumes' in inspect_data
+            assert self.mount_dest in inspect_data['Volumes']
+            assert (
+                self.mount_origin == inspect_data['Volumes'][self.mount_dest]
             )
-            self.assertIn(self.mount_dest, inspect_data['VolumesRW'])
-            self.assertFalse(inspect_data['VolumesRW'][self.mount_dest])
+            assert self.mount_dest in inspect_data['VolumesRW']
+            assert not inspect_data['VolumesRW'][self.mount_dest]
         else:
-            self.assertIn('Mounts', inspect_data)
+            assert 'Mounts' in inspect_data
             filtered = list(filter(
                 lambda x: x['Destination'] == self.mount_dest,
                 inspect_data['Mounts']
             ))
-            self.assertEqual(len(filtered), 1)
+            assert len(filtered) == 1
             mount_data = filtered[0]
-            self.assertEqual(mount_data['Source'], self.mount_origin)
-            self.assertEqual(mount_data['RW'], rw)
+            assert mount_data['Source'] == self.mount_origin
+            assert mount_data['RW'] == rw
 
     def run_with_volume(self, ro, *args, **kwargs):
         return self.run_container(
@@ -659,7 +657,7 @@ class ArchiveTest(BaseAPIIntegrationTest):
             retrieved_data = helpers.untar_file(destination, 'data.txt')
             if six.PY3:
                 retrieved_data = retrieved_data.decode('utf-8')
-            self.assertEqual(data, retrieved_data.strip())
+            assert data == retrieved_data.strip()
 
     def test_get_file_stat_from_container(self):
         data = 'The Maid and the Pocket Watch of Blood'
@@ -671,10 +669,10 @@ class ArchiveTest(BaseAPIIntegrationTest):
         self.client.start(ctnr)
         self.client.wait(ctnr)
         strm, stat = self.client.get_archive(ctnr, '/vol1/data.txt')
-        self.assertIn('name', stat)
-        self.assertEqual(stat['name'], 'data.txt')
-        self.assertIn('size', stat)
-        self.assertEqual(stat['size'], len(data))
+        assert 'name' in stat
+        assert stat['name'] == 'data.txt'
+        assert 'size' in stat
+        assert stat['size'] == len(data)
 
     def test_copy_file_to_container(self):
         data = b'Deaf To All But The Song'
@@ -697,7 +695,7 @@ class ArchiveTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
             data = data.decode('utf-8')
-        self.assertEqual(logs.strip(), data)
+        assert logs.strip() == data
 
     def test_copy_directory_to_container(self):
         files = ['a.py', 'b.py', 'foo/b.py']
@@ -715,10 +713,10 @@ class ArchiveTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
         results = logs.strip().split()
-        self.assertIn('a.py', results)
-        self.assertIn('b.py', results)
-        self.assertIn('foo/', results)
-        self.assertIn('bar/', results)
+        assert 'a.py' in results
+        assert 'b.py' in results
+        assert 'foo/' in results
+        assert 'bar/' in results
 
 
 class RenameContainerTest(BaseAPIIntegrationTest):
@@ -726,49 +724,49 @@ class RenameContainerTest(BaseAPIIntegrationTest):
         version = self.client.version()['Version']
         name = 'hong_meiling'
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.rename(res, name)
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Name', inspect)
+        assert 'Name' in inspect
         if version == '1.5.0':
-            self.assertEqual(name, inspect['Name'])
+            assert name == inspect['Name']
         else:
-            self.assertEqual('/{0}'.format(name), inspect['Name'])
+            assert '/{0}'.format(name) == inspect['Name']
 
 
 class StartContainerTest(BaseAPIIntegrationTest):
     def test_start_container(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
 
     def test_start_container_with_dict_instead_of_id(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res)
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
 
     def test_run_shlex_commands(self):
         commands = [
@@ -788,7 +786,7 @@ class StartContainerTest(BaseAPIIntegrationTest):
             self.client.start(id)
             self.tmp_containers.append(id)
             exitcode = self.client.wait(id)
-            self.assertEqual(exitcode, 0, msg=cmd)
+            assert exitcode == 0, cmd
 
 
 class WaitTest(BaseAPIIntegrationTest):
@@ -798,12 +796,12 @@ class WaitTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         inspect = self.client.inspect_container(id)
-        self.assertIn('Running', inspect['State'])
-        self.assertEqual(inspect['State']['Running'], False)
-        self.assertIn('ExitCode', inspect['State'])
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        assert 'Running' in inspect['State']
+        assert inspect['State']['Running'] is False
+        assert 'ExitCode' in inspect['State']
+        assert inspect['State']['ExitCode'] == exitcode
 
     def test_wait_with_dict_instead_of_id(self):
         res = self.client.create_container(BUSYBOX, ['sleep', '3'])
@@ -811,12 +809,12 @@ class WaitTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(res)
         exitcode = self.client.wait(res)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         inspect = self.client.inspect_container(res)
-        self.assertIn('Running', inspect['State'])
-        self.assertEqual(inspect['State']['Running'], False)
-        self.assertIn('ExitCode', inspect['State'])
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        assert 'Running' in inspect['State']
+        assert inspect['State']['Running'] is False
+        assert 'ExitCode' in inspect['State']
+        assert inspect['State']['ExitCode'] == exitcode
 
     @requires_api_version('1.30')
     def test_wait_with_condition(self):
@@ -844,9 +842,9 @@ class LogsTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id)
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_tail_option(self):
         snippet = '''Line1
@@ -858,9 +856,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id, tail=1)
-        self.assertEqual(logs, 'Line2\n'.encode(encoding='ascii'))
+        assert logs == 'Line2\n'.encode(encoding='ascii')
 
     def test_logs_streaming_and_follow(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -875,9 +873,9 @@ Line2'''
             logs += chunk
 
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
 
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_dict_instead_of_id(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -888,9 +886,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(container)
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_tail_0(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -901,9 +899,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id, tail=0)
-        self.assertEqual(logs, ''.encode(encoding='ascii'))
+        assert logs == ''.encode(encoding='ascii')
 
     @requires_api_version('1.35')
     def test_logs_with_until(self):
@@ -929,12 +927,12 @@ class DiffTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         diff = self.client.diff(id)
         test_diff = [x for x in diff if x.get('Path', None) == '/test']
-        self.assertEqual(len(test_diff), 1)
-        self.assertIn('Kind', test_diff[0])
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        assert len(test_diff) == 1
+        assert 'Kind' in test_diff[0]
+        assert test_diff[0]['Kind'] == 1
 
     def test_diff_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['touch', '/test'])
@@ -942,12 +940,12 @@ class DiffTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         diff = self.client.diff(container)
         test_diff = [x for x in diff if x.get('Path', None) == '/test']
-        self.assertEqual(len(test_diff), 1)
-        self.assertIn('Kind', test_diff[0])
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        assert len(test_diff) == 1
+        assert 'Kind' in test_diff[0]
+        assert test_diff[0]['Kind'] == 1
 
 
 class StopTest(BaseAPIIntegrationTest):
@@ -958,23 +956,23 @@ class StopTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.stop(id, timeout=2)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_stop_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
-        self.assertIn('Id', container)
+        assert 'Id' in container
         id = container['Id']
         self.client.start(container)
         self.tmp_containers.append(id)
         self.client.stop(container, timeout=2)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'Running' in state
+        assert state['Running'] is False
 
 
 class KillTest(BaseAPIIntegrationTest):
@@ -985,12 +983,12 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_kill_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
@@ -999,12 +997,12 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(container)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_kill_with_signal(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1014,14 +1012,14 @@ class KillTest(BaseAPIIntegrationTest):
             id, signal=signal.SIGKILL if not IS_WINDOWS_PLATFORM else 9
         )
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
     def test_kill_with_signal_name(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1029,14 +1027,14 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id, signal='SIGKILL')
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
     def test_kill_with_signal_integer(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1044,14 +1042,14 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id, signal=9)
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
 
 class PortTest(BaseAPIIntegrationTest):
@@ -1079,8 +1077,8 @@ class PortTest(BaseAPIIntegrationTest):
 
             ip, host_port = port_binding['HostIp'], port_binding['HostPort']
 
-            self.assertEqual(ip, port_bindings[port][0])
-            self.assertEqual(host_port, port_bindings[port][1])
+            assert ip == port_bindings[port][0]
+            assert host_port == port_bindings[port][1]
 
         self.client.kill(id)
 
@@ -1116,13 +1114,12 @@ class ContainerTopTest(BaseAPIIntegrationTest):
 
         self.client.start(container)
         res = self.client.top(container, 'waux')
-        self.assertEqual(
-            res['Titles'],
-            ['USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
-                'TTY', 'STAT', 'START', 'TIME', 'COMMAND'],
-        )
-        self.assertEqual(len(res['Processes']), 1)
-        self.assertEqual(res['Processes'][0][10], 'sleep 60')
+        assert res['Titles'] == [
+            'USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
+            'TTY', 'STAT', 'START', 'TIME', 'COMMAND'
+        ]
+        assert len(res['Processes']) == 1
+        assert res['Processes'][0][10] == 'sleep 60'
 
 
 class RestartContainerTest(BaseAPIIntegrationTest):
@@ -1132,37 +1129,37 @@ class RestartContainerTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         info = self.client.inspect_container(id)
-        self.assertIn('State', info)
-        self.assertIn('StartedAt', info['State'])
+        assert 'State' in info
+        assert 'StartedAt' in info['State']
         start_time1 = info['State']['StartedAt']
         self.client.restart(id, timeout=2)
         info2 = self.client.inspect_container(id)
-        self.assertIn('State', info2)
-        self.assertIn('StartedAt', info2['State'])
+        assert 'State' in info2
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
-        self.assertIn('Running', info2['State'])
-        self.assertEqual(info2['State']['Running'], True)
+        assert start_time1 != start_time2
+        assert 'Running' in info2['State']
+        assert info2['State']['Running'] is True
         self.client.kill(id)
 
     def test_restart_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
-        self.assertIn('Id', container)
+        assert 'Id' in container
         id = container['Id']
         self.client.start(container)
         self.tmp_containers.append(id)
         info = self.client.inspect_container(id)
-        self.assertIn('State', info)
-        self.assertIn('StartedAt', info['State'])
+        assert 'State' in info
+        assert 'StartedAt' in info['State']
         start_time1 = info['State']['StartedAt']
         self.client.restart(container, timeout=2)
         info2 = self.client.inspect_container(id)
-        self.assertIn('State', info2)
-        self.assertIn('StartedAt', info2['State'])
+        assert 'State' in info2
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
-        self.assertIn('Running', info2['State'])
-        self.assertEqual(info2['State']['Running'], True)
+        assert start_time1 != start_time2
+        assert 'Running' in info2['State']
+        assert info2['State']['Running'] is True
         self.client.kill(id)
 
 
@@ -1175,7 +1172,7 @@ class RemoveContainerTest(BaseAPIIntegrationTest):
         self.client.remove_container(id)
         containers = self.client.containers(all=True)
         res = [x for x in containers if 'Id' in x and x['Id'].startswith(id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
     def test_remove_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['true'])
@@ -1185,7 +1182,7 @@ class RemoveContainerTest(BaseAPIIntegrationTest):
         self.client.remove_container(container)
         containers = self.client.containers(all=True)
         res = [x for x in containers if 'Id' in x and x['Id'].startswith(id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
 
 class AttachContainerTest(BaseAPIIntegrationTest):
@@ -1196,7 +1193,7 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         sock = self.client.attach_socket(container, ws=False)
-        self.assertTrue(sock.fileno() > -1)
+        assert sock.fileno() > -1
 
     def test_run_container_reading_socket(self):
         line = 'hi there and stuff and things, words!'
@@ -1213,9 +1210,9 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         self.client.start(container)
 
         next_size = next_frame_size(pty_stdout)
-        self.assertEqual(next_size, len(line))
+        assert next_size == len(line)
         data = read_exactly(pty_stdout, next_size)
-        self.assertEqual(data.decode('utf-8'), line)
+        assert data.decode('utf-8') == line
 
     def test_attach_no_stream(self):
         container = self.client.create_container(
@@ -1235,25 +1232,25 @@ class PauseTest(BaseAPIIntegrationTest):
         self.client.start(container)
         self.client.pause(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], True)
-        self.assertIn('Paused', state)
-        self.assertEqual(state['Paused'], True)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] == 0
+        assert 'Running' in state
+        assert state['Running'] is True
+        assert 'Paused' in state
+        assert state['Paused'] is True
 
         self.client.unpause(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], True)
-        self.assertIn('Paused', state)
-        self.assertEqual(state['Paused'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] == 0
+        assert 'Running' in state
+        assert state['Running'] is True
+        assert 'Paused' in state
+        assert state['Paused'] is False
 
 
 class PruneTest(BaseAPIIntegrationTest):
@@ -1283,10 +1280,10 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
         response = self.client.stats(container, stream=0)
         self.client.kill(container)
 
-        self.assertEqual(type(response), dict)
+        assert type(response) == dict
         for key in ['read', 'networks', 'precpu_stats', 'cpu_stats',
                     'memory_stats', 'blkio_stats']:
-            self.assertIn(key, response)
+            assert key in response
 
         @requires_api_version('1.17')
         def test_get_container_stats_stream(self):
@@ -1297,10 +1294,10 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
             self.client.start(container)
             stream = self.client.stats(container)
             for chunk in stream:
-                self.assertEqual(type(chunk), dict)
+                assert type(chunk) == dict
                 for key in ['read', 'network', 'precpu_stats', 'cpu_stats',
                             'memory_stats', 'blkio_stats']:
-                    self.assertIn(key, chunk)
+                    assert key in chunk
 
 
 class ContainerUpdateTest(BaseAPIIntegrationTest):
@@ -1317,7 +1314,7 @@ class ContainerUpdateTest(BaseAPIIntegrationTest):
         self.client.start(container)
         self.client.update_container(container, mem_limit=new_mem_limit)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['Memory'], new_mem_limit)
+        assert inspect_data['HostConfig']['Memory'] == new_mem_limit
 
     @requires_api_version('1.23')
     def test_restart_policy_update(self):
@@ -1340,12 +1337,12 @@ class ContainerUpdateTest(BaseAPIIntegrationTest):
         self.client.update_container(container,
                                      restart_policy=new_restart_policy)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(
-            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'],
+        assert (
+            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'] ==
             new_restart_policy['MaximumRetryCount']
         )
-        self.assertEqual(
-            inspect_data['HostConfig']['RestartPolicy']['Name'],
+        assert (
+            inspect_data['HostConfig']['RestartPolicy']['Name'] ==
             new_restart_policy['Name']
         )
 
@@ -1362,7 +1359,7 @@ class ContainerCPUTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['CpuShares'], 512)
+        assert inspect_data['HostConfig']['CpuShares'] == 512
 
     @requires_api_version('1.18')
     def test_container_cpuset(self):
@@ -1375,7 +1372,7 @@ class ContainerCPUTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['CpusetCpus'], cpuset_cpus)
+        assert inspect_data['HostConfig']['CpusetCpus'] == cpuset_cpus
 
     @requires_api_version('1.25')
     def test_create_with_runtime(self):
@@ -1419,11 +1416,11 @@ class LinkTest(BaseAPIIntegrationTest):
         # Link is gone
         containers = self.client.containers(all=True)
         retrieved = [x for x in containers if link_name in x['Names']]
-        self.assertEqual(len(retrieved), 0)
+        assert len(retrieved) == 0
 
         # Containers are still there
         retrieved = [
             x for x in containers if x['Id'].startswith(container1_id) or
             x['Id'].startswith(container2_id)
         ]
-        self.assertEqual(len(retrieved), 2)
+        assert len(retrieved) == 2
diff --git a/tests/integration/api_exec_test.py b/tests/integration/api_exec_test.py
index 0d42e19..cd97c68 100644
--- a/tests/integration/api_exec_test.py
+++ b/tests/integration/api_exec_test.py
@@ -14,10 +14,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, ['echo', 'hello'])
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'hello\n')
+        assert exec_log == b'hello\n'
 
     def test_exec_command_string(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -27,10 +27,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'echo hello world')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'hello world\n')
+        assert exec_log == b'hello world\n'
 
     def test_exec_command_as_user(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -40,10 +40,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'whoami', user='default')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'default\n')
+        assert exec_log == b'default\n'
 
     def test_exec_command_as_root(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -53,10 +53,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'whoami')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'root\n')
+        assert exec_log == b'root\n'
 
     def test_exec_command_streaming(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -66,12 +66,12 @@ class ExecTest(BaseAPIIntegrationTest):
         self.client.start(id)
 
         exec_id = self.client.exec_create(id, ['echo', 'hello\nworld'])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         res = b''
         for chunk in self.client.exec_start(exec_id, stream=True):
             res += chunk
-        self.assertEqual(res, b'hello\nworld\n')
+        assert res == b'hello\nworld\n'
 
     def test_exec_start_socket(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -84,15 +84,15 @@ class ExecTest(BaseAPIIntegrationTest):
         # `echo` appends CRLF, `printf` doesn't
         exec_id = self.client.exec_create(
             container_id, ['printf', line], tty=True)
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         socket = self.client.exec_start(exec_id, socket=True)
         self.addCleanup(socket.close)
 
         next_size = next_frame_size(socket)
-        self.assertEqual(next_size, len(line))
+        assert next_size == len(line)
         data = read_exactly(socket, next_size)
-        self.assertEqual(data.decode('utf-8'), line)
+        assert data.decode('utf-8') == line
 
     def test_exec_start_detached(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -103,11 +103,11 @@ class ExecTest(BaseAPIIntegrationTest):
 
         exec_id = self.client.exec_create(
             container_id, ['printf', "asdqwe"])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         response = self.client.exec_start(exec_id, detach=True)
 
-        self.assertEqual(response, "")
+        assert response == ""
 
     def test_exec_inspect(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -117,11 +117,11 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         exec_id = self.client.exec_create(id, ['mkdir', '/does/not/exist'])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
         self.client.exec_start(exec_id)
         exec_info = self.client.exec_inspect(exec_id)
-        self.assertIn('ExitCode', exec_info)
-        self.assertNotEqual(exec_info['ExitCode'], 0)
+        assert 'ExitCode' in exec_info
+        assert exec_info['ExitCode'] != 0
 
     @requires_api_version('1.25')
     def test_exec_command_with_env(self):
diff --git a/tests/integration/api_healthcheck_test.py b/tests/integration/api_healthcheck_test.py
index 211042d..5dbac37 100644
--- a/tests/integration/api_healthcheck_test.py
+++ b/tests/integration/api_healthcheck_test.py
@@ -20,8 +20,9 @@ class HealthcheckTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
 
         res = self.client.inspect_container(container)
-        assert res['Config']['Healthcheck']['Test'] == \
-            ['CMD-SHELL', 'echo "hello world"']
+        assert res['Config']['Healthcheck']['Test'] == [
+            'CMD-SHELL', 'echo "hello world"'
+        ]
 
     @helpers.requires_api_version('1.24')
     def test_healthcheck_passes(self):
diff --git a/tests/integration/api_image_test.py b/tests/integration/api_image_test.py
index ae93190..ab638c9 100644
--- a/tests/integration/api_image_test.py
+++ b/tests/integration/api_image_test.py
@@ -21,19 +21,19 @@ from .base import BaseAPIIntegrationTest, BUSYBOX
 class ListImagesTest(BaseAPIIntegrationTest):
     def test_images(self):
         res1 = self.client.images(all=True)
-        self.assertIn('Id', res1[0])
+        assert 'Id' in res1[0]
         res10 = res1[0]
-        self.assertIn('Created', res10)
-        self.assertIn('RepoTags', res10)
+        assert 'Created' in res10
+        assert 'RepoTags' in res10
         distinct = []
         for img in res1:
             if img['Id'] not in distinct:
                 distinct.append(img['Id'])
-        self.assertEqual(len(distinct), self.client.info()['Images'])
+        assert len(distinct) == self.client.info()['Images']
 
     def test_images_quiet(self):
         res1 = self.client.images(quiet=True)
-        self.assertEqual(type(res1[0]), six.text_type)
+        assert type(res1[0]) == six.text_type
 
 
 class PullImageTest(BaseAPIIntegrationTest):
@@ -44,12 +44,10 @@ class PullImageTest(BaseAPIIntegrationTest):
             pass
         res = self.client.pull('hello-world', tag='latest')
         self.tmp_imgs.append('hello-world')
-        self.assertEqual(type(res), six.text_type)
-        self.assertGreaterEqual(
-            len(self.client.images('hello-world')), 1
-        )
+        assert type(res) == six.text_type
+        assert len(self.client.images('hello-world')) >= 1
         img_info = self.client.inspect_image('hello-world')
-        self.assertIn('Id', img_info)
+        assert 'Id' in img_info
 
     def test_pull_streaming(self):
         try:
@@ -61,11 +59,9 @@ class PullImageTest(BaseAPIIntegrationTest):
         self.tmp_imgs.append('hello-world')
         for chunk in stream:
             assert isinstance(chunk, dict)
-        self.assertGreaterEqual(
-            len(self.client.images('hello-world')), 1
-        )
+        assert len(self.client.images('hello-world')) >= 1
         img_info = self.client.inspect_image('hello-world')
-        self.assertIn('Id', img_info)
+        assert 'Id' in img_info
 
     @requires_api_version('1.32')
     @requires_experimental(until=None)
@@ -84,18 +80,18 @@ class CommitTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         res = self.client.commit(id)
-        self.assertIn('Id', res)
+        assert 'Id' in res
         img_id = res['Id']
         self.tmp_imgs.append(img_id)
         img = self.client.inspect_image(img_id)
-        self.assertIn('Container', img)
-        self.assertTrue(img['Container'].startswith(id))
-        self.assertIn('ContainerConfig', img)
-        self.assertIn('Image', img['ContainerConfig'])
-        self.assertEqual(BUSYBOX, img['ContainerConfig']['Image'])
+        assert 'Container' in img
+        assert img['Container'].startswith(id)
+        assert 'ContainerConfig' in img
+        assert 'Image' in img['ContainerConfig']
+        assert BUSYBOX == img['ContainerConfig']['Image']
         busybox_id = self.client.inspect_image(BUSYBOX)['Id']
-        self.assertIn('Parent', img)
-        self.assertEqual(img['Parent'], busybox_id)
+        assert 'Parent' in img
+        assert img['Parent'] == busybox_id
 
     def test_commit_with_changes(self):
         cid = self.client.create_container(BUSYBOX, ['touch', '/test'])
@@ -119,14 +115,14 @@ class RemoveImageTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         res = self.client.commit(id)
-        self.assertIn('Id', res)
+        assert 'Id' in res
         img_id = res['Id']
         self.tmp_imgs.append(img_id)
         logs = self.client.remove_image(img_id, force=True)
-        self.assertIn({"Deleted": img_id}, logs)
+        assert {"Deleted": img_id} in logs
         images = self.client.images(all=True)
         res = [x for x in images if x['Id'].startswith(img_id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
 
 class ImportImageTest(BaseAPIIntegrationTest):
@@ -180,7 +176,7 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
         img_id = result['status']
         self.tmp_imgs.append(img_id)
@@ -195,9 +191,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 
@@ -210,9 +206,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 
@@ -305,9 +301,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 
diff --git a/tests/integration/api_network_test.py b/tests/integration/api_network_test.py
index 10e09dd..ec92bd7 100644
--- a/tests/integration/api_network_test.py
+++ b/tests/integration/api_network_test.py
@@ -24,24 +24,24 @@ class TestNetworks(BaseAPIIntegrationTest):
         net_name, net_id = self.create_network()
 
         networks = self.client.networks()
-        self.assertTrue(net_id in [n['Id'] for n in networks])
+        assert net_id in [n['Id'] for n in networks]
 
         networks_by_name = self.client.networks(names=[net_name])
-        self.assertEqual([n['Id'] for n in networks_by_name], [net_id])
+        assert [n['Id'] for n in networks_by_name] == [net_id]
 
         networks_by_partial_id = self.client.networks(ids=[net_id[:8]])
-        self.assertEqual([n['Id'] for n in networks_by_partial_id], [net_id])
+        assert [n['Id'] for n in networks_by_partial_id] == [net_id]
 
     @requires_api_version('1.21')
     def test_inspect_network(self):
         net_name, net_id = self.create_network()
 
         net = self.client.inspect_network(net_id)
-        self.assertEqual(net['Id'], net_id)
-        self.assertEqual(net['Name'], net_name)
-        self.assertEqual(net['Driver'], 'bridge')
-        self.assertEqual(net['Scope'], 'local')
-        self.assertEqual(net['IPAM']['Driver'], 'default')
+        assert net['Id'] == net_id
+        assert net['Name'] == net_name
+        assert net['Driver'] == 'bridge'
+        assert net['Scope'] == 'local'
+        assert net['IPAM']['Driver'] == 'default'
 
     @requires_api_version('1.21')
     def test_create_network_with_ipam_config(self):
@@ -103,21 +103,20 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         self.client.connect_container_to_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
-            [container['Id']]
-        )
+        assert list(network_data['Containers'].keys()) == [
+            container['Id']
+        ]
 
         with pytest.raises(docker.errors.APIError):
             self.client.connect_container_to_network(container, net_id)
 
         self.client.disconnect_container_from_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         with pytest.raises(docker.errors.APIError):
             self.client.disconnect_container_from_network(container, net_id)
@@ -131,18 +130,16 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         self.client.connect_container_to_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
+        assert list(network_data['Containers'].keys()) == \
             [container['Id']]
-        )
 
         self.client.disconnect_container_from_network(container, net_id, True)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         with pytest.raises(docker.errors.APIError):
             self.client.disconnect_container_from_network(
@@ -179,13 +176,12 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
-            [container['Id']])
+        assert list(network_data['Containers'].keys()) == \
+            [container['Id']]
 
         self.client.disconnect_container_from_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
     @requires_api_version('1.22')
     def test_create_with_aliases(self):
@@ -233,14 +229,11 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data[
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
-                'IPv4Address'
-            ],
-            '132.124.0.23'
-        )
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv4Address']\
+            == '132.124.0.23'
 
     @requires_api_version('1.22')
     def test_create_with_ipv6_address(self):
@@ -262,14 +255,11 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data[
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
-                'IPv6Address'
-            ],
-            '2001:389::f00d'
-        )
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv6Address']\
+            == '2001:389::f00d'
 
     @requires_api_version('1.24')
     def test_create_with_linklocal_ips(self):
@@ -305,10 +295,12 @@ class TestNetworks(BaseAPIIntegrationTest):
             }),
         )
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
-            ['docker-py-test-upstream:bar'])
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['Links'] == [
+            'docker-py-test-upstream:bar'
+        ]
 
         self.create_and_start(
             name='docker-py-test-upstream',
@@ -320,7 +312,7 @@ class TestNetworks(BaseAPIIntegrationTest):
     @requires_api_version('1.21')
     def test_create_check_duplicate(self):
         net_name, net_id = self.create_network()
-        with self.assertRaises(docker.errors.APIError):
+        with pytest.raises(docker.errors.APIError):
             self.client.create_network(net_name, check_duplicate=True)
         net_id = self.client.create_network(net_name, check_duplicate=False)
         self.tmp_networks.append(net_id['Id'])
@@ -337,10 +329,12 @@ class TestNetworks(BaseAPIIntegrationTest):
             container, net_name,
             links=[('docker-py-test-upstream', 'bar')])
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
-            ['docker-py-test-upstream:bar'])
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['Links'] == [
+            'docker-py-test-upstream:bar'
+        ]
 
         self.create_and_start(
             name='docker-py-test-upstream',
@@ -373,9 +367,7 @@ class TestNetworks(BaseAPIIntegrationTest):
 
         container_data = self.client.inspect_container(container)
         net_data = container_data['NetworkSettings']['Networks'][net_name]
-        self.assertEqual(
-            net_data['IPAMConfig']['IPv4Address'], '172.28.5.24'
-        )
+        assert net_data['IPAMConfig']['IPv4Address'] == '172.28.5.24'
 
     @requires_api_version('1.22')
     def test_connect_with_ipv6_address(self):
@@ -401,9 +393,7 @@ class TestNetworks(BaseAPIIntegrationTest):
 
         container_data = self.client.inspect_container(container)
         net_data = container_data['NetworkSettings']['Networks'][net_name]
-        self.assertEqual(
-            net_data['IPAMConfig']['IPv6Address'], '2001:389::f00d'
-        )
+        assert net_data['IPAMConfig']['IPv6Address'] == '2001:389::f00d'
 
     @requires_api_version('1.23')
     def test_create_internal_networks(self):
diff --git a/tests/integration/api_volume_test.py b/tests/integration/api_volume_test.py
index 5a4bb1e..e09f12a 100644
--- a/tests/integration/api_volume_test.py
+++ b/tests/integration/api_volume_test.py
@@ -11,10 +11,10 @@ class TestVolumes(BaseAPIIntegrationTest):
         name = 'perfectcherryblossom'
         self.tmp_volumes.append(name)
         result = self.client.create_volume(name)
-        self.assertIn('Name', result)
-        self.assertEqual(result['Name'], name)
-        self.assertIn('Driver', result)
-        self.assertEqual(result['Driver'], 'local')
+        assert 'Name' in result
+        assert result['Name'] == name
+        assert 'Driver' in result
+        assert result['Driver'] == 'local'
 
     def test_create_volume_invalid_driver(self):
         driver_name = 'invalid.driver'
@@ -27,16 +27,16 @@ class TestVolumes(BaseAPIIntegrationTest):
         self.tmp_volumes.append(name)
         volume_info = self.client.create_volume(name)
         result = self.client.volumes()
-        self.assertIn('Volumes', result)
+        assert 'Volumes' in result
         volumes = result['Volumes']
-        self.assertIn(volume_info, volumes)
+        assert volume_info in volumes
 
     def test_inspect_volume(self):
         name = 'embodimentofscarletdevil'
         self.tmp_volumes.append(name)
         volume_info = self.client.create_volume(name)
         result = self.client.inspect_volume(name)
-        self.assertEqual(volume_info, result)
+        assert volume_info == result
 
     def test_inspect_nonexistent_volume(self):
         name = 'embodimentofscarletdevil'
diff --git a/tests/integration/errors_test.py b/tests/integration/errors_test.py
index dc5cef4..ac74d72 100644
--- a/tests/integration/errors_test.py
+++ b/tests/integration/errors_test.py
@@ -1,14 +1,15 @@
 from docker.errors import APIError
 from .base import BaseAPIIntegrationTest, BUSYBOX
+import pytest
 
 
 class ErrorsTest(BaseAPIIntegrationTest):
     def test_api_error_parses_json(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '10'])
         self.client.start(container['Id'])
-        with self.assertRaises(APIError) as cm:
+        with pytest.raises(APIError) as cm:
             self.client.remove_container(container['Id'])
-        explanation = cm.exception.explanation
+        explanation = cm.value.explanation
         assert 'You cannot remove a running container' in explanation
         assert '{"message":' not in explanation
         self.client.remove_container(container['Id'], force=True)
diff --git a/tests/integration/models_containers_test.py b/tests/integration/models_containers_test.py
index 3c33cb0..2d01f22 100644
--- a/tests/integration/models_containers_test.py
+++ b/tests/integration/models_containers_test.py
@@ -10,10 +10,9 @@ class ContainerCollectionTest(BaseIntegrationTest):
 
     def test_run(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        self.assertEqual(
-            client.containers.run("alpine", "echo hello world", remove=True),
-            b'hello world\n'
-        )
+        assert client.containers.run(
+            "alpine", "echo hello world", remove=True
+        ) == b'hello world\n'
 
     def test_run_detach(self):
         client = docker.from_env(version=TEST_API_VERSION)
@@ -24,16 +23,16 @@ class ContainerCollectionTest(BaseIntegrationTest):
 
     def test_run_with_error(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.ContainerError) as cm:
+        with pytest.raises(docker.errors.ContainerError) as cm:
             client.containers.run("alpine", "cat /test", remove=True)
-        assert cm.exception.exit_status == 1
-        assert "cat /test" in str(cm.exception)
-        assert "alpine" in str(cm.exception)
-        assert "No such file or directory" in str(cm.exception)
+        assert cm.value.exit_status == 1
+        assert "cat /test" in cm.exconly()
+        assert "alpine" in cm.exconly()
+        assert "No such file or directory" in cm.exconly()
 
     def test_run_with_image_that_does_not_exist(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.ImageNotFound):
+        with pytest.raises(docker.errors.ImageNotFound):
             client.containers.run("dockerpytest_does_not_exist")
 
     def test_run_with_volume(self):
@@ -52,7 +51,7 @@ class ContainerCollectionTest(BaseIntegrationTest):
             "alpine", "cat /insidecontainer/test",
             volumes=["%s:/insidecontainer" % path]
         )
-        self.assertEqual(out, b'hello\n')
+        assert out == b'hello\n'
 
     def test_run_with_named_volume(self):
         client = docker.from_env(version=TEST_API_VERSION)
@@ -70,7 +69,7 @@ class ContainerCollectionTest(BaseIntegrationTest):
             "alpine", "cat /insidecontainer/test",
             volumes=["somevolume:/insidecontainer"]
         )
-        self.assertEqual(out, b'hello\n')
+        assert out == b'hello\n'
 
     def test_run_with_network(self):
         net_name = random_name()
@@ -170,10 +169,9 @@ class ContainerTest(BaseIntegrationTest):
         self.tmp_containers.append(container.id)
         container.wait()
         image = container.commit()
-        self.assertEqual(
-            client.containers.run(image.id, "cat /test", remove=True),
-            b"hello\n"
-        )
+        assert client.containers.run(
+            image.id, "cat /test", remove=True
+        ) == b"hello\n"
 
     def test_diff(self):
         client = docker.from_env(version=TEST_API_VERSION)
diff --git a/tests/integration/models_images_test.py b/tests/integration/models_images_test.py
index 94164ce..9313916 100644
--- a/tests/integration/models_images_test.py
+++ b/tests/integration/models_images_test.py
@@ -21,16 +21,15 @@ class ImageCollectionTest(BaseIntegrationTest):
     # @pytest.mark.xfail(reason='Engine 1.13 responds with status 500')
     def test_build_with_error(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.BuildError) as cm:
+        with pytest.raises(docker.errors.BuildError) as cm:
             client.images.build(fileobj=io.BytesIO(
                 "FROM alpine\n"
                 "RUN exit 1".encode('ascii')
             ))
-        print(cm.exception)
-        assert str(cm.exception) == (
+        assert (
             "The command '/bin/sh -c exit 1' returned a non-zero code: 1"
-        )
-        assert cm.exception.build_log
+        ) in cm.exconly()
+        assert cm.value.build_log
 
     def test_build_with_multiple_success(self):
         client = docker.from_env(version=TEST_API_VERSION)
diff --git a/tests/integration/models_services_test.py b/tests/integration/models_services_test.py
index 827242a..39cccf8 100644
--- a/tests/integration/models_services_test.py
+++ b/tests/integration/models_services_test.py
@@ -6,6 +6,7 @@ from .. import helpers
 from .base import TEST_API_VERSION
 from docker.errors import InvalidArgument
 from docker.types.services import ServiceMode
+import pytest
 
 
 class ServiceTest(unittest.TestCase):
@@ -265,8 +266,7 @@ class ServiceTest(unittest.TestCase):
         while len(tasks) == 0:
             tasks = service.tasks()
         assert len(tasks) == 1
-        with self.assertRaises(InvalidArgument,
-                               msg='Cannot scale a global container'):
+        with pytest.raises(InvalidArgument):
             service.scale(2)
 
         assert len(tasks) == 1
diff --git a/tests/integration/models_swarm_test.py b/tests/integration/models_swarm_test.py
index dadd77d..f39f0d3 100644
--- a/tests/integration/models_swarm_test.py
+++ b/tests/integration/models_swarm_test.py
@@ -4,6 +4,7 @@ import docker
 
 from .. import helpers
 from .base import TEST_API_VERSION
+import pytest
 
 
 class SwarmTest(unittest.TestCase):
@@ -24,11 +25,9 @@ class SwarmTest(unittest.TestCase):
         assert client.swarm.attrs['Spec']['Raft']['SnapshotInterval'] == 10000
         assert client.swarm.id
         assert client.swarm.leave(force=True)
-        with self.assertRaises(docker.errors.APIError) as cm:
+        with pytest.raises(docker.errors.APIError) as cm:
             client.swarm.reload()
         assert (
-            # FIXME: test for both until
-            # https://github.com/docker/docker/issues/29192 is resolved
-            cm.exception.response.status_code == 406 or
-            cm.exception.response.status_code == 503
+            cm.value.response.status_code == 406 or
+            cm.value.response.status_code == 503
         )
diff --git a/tests/integration/regression_test.py b/tests/integration/regression_test.py
index e3e6d9b..0fd4e43 100644
--- a/tests/integration/regression_test.py
+++ b/tests/integration/regression_test.py
@@ -5,15 +5,16 @@ import docker
 import six
 
 from .base import BaseAPIIntegrationTest, BUSYBOX
+import pytest
 
 
 class TestRegressions(BaseAPIIntegrationTest):
     def test_443_handle_nonchunked_response_in_stream(self):
         dfile = io.BytesIO()
-        with self.assertRaises(docker.errors.APIError) as exc:
+        with pytest.raises(docker.errors.APIError) as exc:
             for line in self.client.build(fileobj=dfile, tag="a/b/c"):
                 pass
-        self.assertEqual(exc.exception.response.status_code, 500)
+        assert exc.value.response.status_code == 500
         dfile.close()
 
     def test_542_truncate_ids_client_side(self):
@@ -21,10 +22,10 @@ class TestRegressions(BaseAPIIntegrationTest):
             self.client.create_container(BUSYBOX, ['true'])
         )
         result = self.client.containers(all=True, trunc=True)
-        self.assertEqual(len(result[0]['Id']), 12)
+        assert len(result[0]['Id']) == 12
 
     def test_647_support_doubleslash_in_image_names(self):
-        with self.assertRaises(docker.errors.APIError):
+        with pytest.raises(docker.errors.APIError):
             self.client.inspect_image('gensokyo.jp//kirisame')
 
     def test_649_handle_timeout_value_none(self):
@@ -53,15 +54,12 @@ class TestRegressions(BaseAPIIntegrationTest):
         )
         self.tmp_containers.append(ctnr)
         self.client.start(ctnr)
-        self.assertEqual(
-            self.client.port(ctnr, 2000)[0]['HostPort'],
-            six.text_type(tcp_port)
-        )
-        self.assertEqual(
-            self.client.port(ctnr, '2000/tcp')[0]['HostPort'],
-            six.text_type(tcp_port)
-        )
-        self.assertEqual(
-            self.client.port(ctnr, '2000/udp')[0]['HostPort'],
-            six.text_type(udp_port)
-        )
+        assert self.client.port(
+            ctnr, 2000
+        )[0]['HostPort'] == six.text_type(tcp_port)
+        assert self.client.port(
+            ctnr, '2000/tcp'
+        )[0]['HostPort'] == six.text_type(tcp_port)
+        assert self.client.port(
+            ctnr, '2000/udp'
+        )[0]['HostPort'] == six.text_type(udp_port)