Merge pull request #1881 from docker/pytest-asserts

Use pytest asserts

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(
+        assert sorted(list(filter(None, logs.split('\n')))) == sorted([
-            sorted(list(filter(None, logs.split('\n')))),
+            '/test/ignored/subdir/excepted-file',
-            sorted(['/test/ignored/subdir/excepted-file',
+            '/test/not-ignored'
-                    '/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)
+        assert len(non_squashed['RootFS']['Layers']) == 4
-        self.assertEqual(len(squashed['RootFS']['Layers']), 2)
+        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')

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)
+        assert 'GoVersion' in res
-        self.assertIn('Version', res)
+        assert 'Version' in res
 
     def test_info(self):
         res = self.client.info()
-        self.assertIn('Containers', res)
+        assert 'Containers' in res
-        self.assertIn('Images', res)
+        assert 'Images' in res
-        self.assertIn('Debug', 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')
+        assert cfg['username'] == 'sakuya'
-        self.assertEqual(cfg['password'], 'izayoi')
+        assert cfg['password'] == 'izayoi'
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+        assert cfg['email'] == 'sakuya@scarlet.net'
-        self.assertEqual(cfg.get('Auth'), None)
+        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')
+        assert cfg['username'] == 'sakuya'
-        self.assertEqual(cfg['password'], 'izayoi')
+        assert cfg['password'] == 'izayoi'
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+        assert cfg['email'] == 'sakuya@scarlet.net'
-        self.assertEqual(cfg.get('Auth'), None)
+        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)
+        assert res is None
-        self.assertTrue(end - start < 2 * self.timeout)
+        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, \
+            assert len(w) == 0, "No warnings produced: {0}".format(
-                "No warnings produced: {0}".format(w[0].message)
+                w[0].message
+            )

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)
+        assert 'Command' in retrieved
-        self.assertEqual(retrieved['Command'], six.text_type('true'))
+        assert retrieved['Command'] == six.text_type('true')
-        self.assertIn('Image', retrieved)
+        assert 'Image' in retrieved
-        self.assertRegex(retrieved['Image'], r'busybox:.*')
+        assert re.search(r'busybox:.*', retrieved['Image'])
-        self.assertIn('Status', retrieved)
+        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)
+        assert 'PidMode' in host_config
-        self.assertEqual(host_config['PidMode'], 'host')
+        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)
+        assert '{0}_NAME='.format(link_env_prefix1) in logs
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix1), logs)
+        assert '{0}_ENV_FOO=1'.format(link_env_prefix1) in logs
-        self.assertIn('{0}_NAME='.format(link_env_prefix2), logs)
+        assert '{0}_NAME='.format(link_env_prefix2) in logs
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix2), 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
+        err = exc.value.explanation
-        self.assertIn(
+        assert 'You cannot remove ' in err
-            'You cannot remove ', 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)
+        assert 'Name' in inspect
-        self.assertEqual('/foobar', inspect['Name'])
+        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)
+        assert 'Config' in inspect
-        self.assertIn('Id', inspect)
+        assert 'Id' in inspect
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
+        assert inspect['Id'].startswith(res['Id'])
-        self.assertIn('Image', inspect)
+        assert 'Image' in inspect
-        self.assertIn('State', inspect)
+        assert 'State' in inspect
-        self.assertIn('Running', inspect['State'])
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
+            assert 'ExitCode' in inspect['State']
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            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,
+        assert mac_address_expected == res['NetworkSettings']['MacAddress']
-                         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)
+        assert '1000' in groups
-        self.assertIn('1001', 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)
+        assert '1000' in groups
-        self.assertIn('1001', 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)
+        assert container_log_config['Type'] == log_config.type
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        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")
+        assert container_log_config['Type'] == "json-file"
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        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")
+        assert container_log_config['Type'] == "json-file"
-        self.assertEqual(container_log_config['Config'], {})
+        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)
+            assert 'Volumes' in inspect_data
-            self.assertIn(self.mount_dest, inspect_data['Volumes'])
+            assert self.mount_dest in inspect_data['Volumes']
-            self.assertEqual(
+            assert (
-                self.mount_origin, inspect_data['Volumes'][self.mount_dest]
+                self.mount_origin == inspect_data['Volumes'][self.mount_dest]
             )
-            self.assertIn(self.mount_dest, inspect_data['VolumesRW'])
+            assert self.mount_dest in inspect_data['VolumesRW']
-            self.assertFalse(inspect_data['VolumesRW'][self.mount_dest])
+            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)
+            assert mount_data['Source'] == self.mount_origin
-            self.assertEqual(mount_data['RW'], rw)
+            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)
+        assert 'name' in stat
-        self.assertEqual(stat['name'], 'data.txt')
+        assert stat['name'] == 'data.txt'
-        self.assertIn('size', stat)
+        assert 'size' in stat
-        self.assertEqual(stat['size'], len(data))
+        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)
+        assert 'a.py' in results
-        self.assertIn('b.py', results)
+        assert 'b.py' in results
-        self.assertIn('foo/', results)
+        assert 'foo/' in results
-        self.assertIn('bar/', 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)
+        assert 'Config' in inspect
-        self.assertIn('Id', inspect)
+        assert 'Id' in inspect
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
+        assert inspect['Id'].startswith(res['Id'])
-        self.assertIn('Image', inspect)
+        assert 'Image' in inspect
-        self.assertIn('State', inspect)
+        assert 'State' in inspect
-        self.assertIn('Running', inspect['State'])
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
+            assert 'ExitCode' in inspect['State']
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            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)
+        assert 'Config' in inspect
-        self.assertIn('Id', inspect)
+        assert 'Id' in inspect
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
+        assert inspect['Id'].startswith(res['Id'])
-        self.assertIn('Image', inspect)
+        assert 'Image' in inspect
-        self.assertIn('State', inspect)
+        assert 'State' in inspect
-        self.assertIn('Running', inspect['State'])
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
+            assert 'ExitCode' in inspect['State']
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            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'])
+        assert 'Running' in inspect['State']
-        self.assertEqual(inspect['State']['Running'], False)
+        assert inspect['State']['Running'] is False
-        self.assertIn('ExitCode', inspect['State'])
+        assert 'ExitCode' in inspect['State']
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        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'])
+        assert 'Running' in inspect['State']
-        self.assertEqual(inspect['State']['Running'], False)
+        assert inspect['State']['Running'] is False
-        self.assertIn('ExitCode', inspect['State'])
+        assert 'ExitCode' in inspect['State']
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        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)
+        assert len(test_diff) == 1
-        self.assertIn('Kind', test_diff[0])
+        assert 'Kind' in test_diff[0]
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        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)
+        assert len(test_diff) == 1
-        self.assertIn('Kind', test_diff[0])
+        assert 'Kind' in test_diff[0]
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        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)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False)
+        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)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False)
+        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)
+        assert 'ExitCode' in state
-        self.assertNotEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] != 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False)
+        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)
+        assert 'ExitCode' in state
-        self.assertNotEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] != 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False)
+        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)
+        assert 'ExitCode' in state
-        self.assertNotEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] != 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False, 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)
+        assert 'ExitCode' in state
-        self.assertNotEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] != 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False, 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)
+        assert 'ExitCode' in state
-        self.assertNotEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] != 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], False, 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])
+            assert ip == port_bindings[port][0]
-            self.assertEqual(host_port, port_bindings[port][1])
+            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(
+        assert res['Titles'] == [
-            res['Titles'],
+            'USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
-            ['USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
+            'TTY', 'STAT', 'START', 'TIME', 'COMMAND'
-                'TTY', 'STAT', 'START', 'TIME', 'COMMAND'],
+        ]
-        )
+        assert len(res['Processes']) == 1
-        self.assertEqual(len(res['Processes']), 1)
+        assert res['Processes'][0][10] == 'sleep 60'
-        self.assertEqual(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)
+        assert 'State' in info
-        self.assertIn('StartedAt', info['State'])
+        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)
+        assert 'State' in info2
-        self.assertIn('StartedAt', info2['State'])
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
+        assert start_time1 != start_time2
-        self.assertIn('Running', info2['State'])
+        assert 'Running' in info2['State']
-        self.assertEqual(info2['State']['Running'], True)
+        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)
+        assert 'State' in info
-        self.assertIn('StartedAt', info['State'])
+        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)
+        assert 'State' in info2
-        self.assertIn('StartedAt', info2['State'])
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
+        assert start_time1 != start_time2
-        self.assertIn('Running', info2['State'])
+        assert 'Running' in info2['State']
-        self.assertEqual(info2['State']['Running'], True)
+        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)
+        assert 'ExitCode' in state
-        self.assertEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] == 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], True)
+        assert state['Running'] is True
-        self.assertIn('Paused', state)
+        assert 'Paused' in state
-        self.assertEqual(state['Paused'], True)
+        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)
+        assert 'ExitCode' in state
-        self.assertEqual(state['ExitCode'], 0)
+        assert state['ExitCode'] == 0
-        self.assertIn('Running', state)
+        assert 'Running' in state
-        self.assertEqual(state['Running'], True)
+        assert state['Running'] is True
-        self.assertIn('Paused', state)
+        assert 'Paused' in state
-        self.assertEqual(state['Paused'], False)
+        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(
+        assert (
-            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'],
+            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'] ==
             new_restart_policy['MaximumRetryCount']
         )
-        self.assertEqual(
+        assert (
-            inspect_data['HostConfig']['RestartPolicy']['Name'],
+            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

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)
+        assert 'ExitCode' in exec_info
-        self.assertNotEqual(exec_info['ExitCode'], 0)
+        assert exec_info['ExitCode'] != 0
 
     @requires_api_version('1.25')
     def test_exec_command_with_env(self):

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'] == \
+        assert res['Config']['Healthcheck']['Test'] == [
-            ['CMD-SHELL', 'echo "hello world"']
+            'CMD-SHELL', 'echo "hello world"'
+        ]
 
     @helpers.requires_api_version('1.24')
     def test_healthcheck_passes(self):

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)
+        assert 'Created' in res10
-        self.assertIn('RepoTags', 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)
+        assert type(res) == six.text_type
-        self.assertGreaterEqual(
+        assert len(self.client.images('hello-world')) >= 1
-            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(
+        assert len(self.client.images('hello-world')) >= 1
-            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)
+        assert 'Container' in img
-        self.assertTrue(img['Container'].startswith(id))
+        assert img['Container'].startswith(id)
-        self.assertIn('ContainerConfig', img)
+        assert 'ContainerConfig' in img
-        self.assertIn('Image', img['ContainerConfig'])
+        assert 'Image' in img['ContainerConfig']
-        self.assertEqual(BUSYBOX, img['ContainerConfig']['Image'])
+        assert BUSYBOX == img['ContainerConfig']['Image']
         busybox_id = self.client.inspect_image(BUSYBOX)['Id']
-        self.assertIn('Parent', img)
+        assert 'Parent' in img
-        self.assertEqual(img['Parent'], busybox_id)
+        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)
 

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)
+        assert net['Id'] == net_id
-        self.assertEqual(net['Name'], net_name)
+        assert net['Name'] == net_name
-        self.assertEqual(net['Driver'], 'bridge')
+        assert net['Driver'] == 'bridge'
-        self.assertEqual(net['Scope'], 'local')
+        assert net['Scope'] == 'local'
-        self.assertEqual(net['IPAM']['Driver'], 'default')
+        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(
+        assert list(network_data['Containers'].keys()) == [
-            list(network_data['Containers'].keys()),
+            container['Id']
-            [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(
+        assert list(network_data['Containers'].keys()) == \
-            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(
+        assert list(network_data['Containers'].keys()) == \
-            list(network_data['Containers'].keys()),
+            [container['Id']]
-            [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)
+        net_settings = self.client.inspect_container(container)[
-        self.assertEqual(
+            'NetworkSettings'
-            container_data[
+        ]
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv4Address']\
-                'IPv4Address'
+            == '132.124.0.23'
-            ],
-            '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)
+        net_settings = self.client.inspect_container(container)[
-        self.assertEqual(
+            'NetworkSettings'
-            container_data[
+        ]
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv6Address']\
-                'IPv6Address'
+            == '2001:389::f00d'
-            ],
-            '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)
+        net_settings = self.client.inspect_container(container)[
-        self.assertEqual(
+            'NetworkSettings'
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
+        ]
-            ['docker-py-test-upstream:bar'])
+        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)
+        net_settings = self.client.inspect_container(container)[
-        self.assertEqual(
+            'NetworkSettings'
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
+        ]
-            ['docker-py-test-upstream:bar'])
+        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(
+        assert net_data['IPAMConfig']['IPv4Address'] == '172.28.5.24'
-            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(
+        assert net_data['IPAMConfig']['IPv6Address'] == '2001:389::f00d'
-            net_data['IPAMConfig']['IPv6Address'], '2001:389::f00d'
-        )
 
     @requires_api_version('1.23')
     def test_create_internal_networks(self):

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)
+        assert 'Name' in result
-        self.assertEqual(result['Name'], name)
+        assert result['Name'] == name
-        self.assertIn('Driver', result)
+        assert 'Driver' in result
-        self.assertEqual(result['Driver'], 'local')
+        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'

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)

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(
+        assert client.containers.run(
-            client.containers.run("alpine", "echo hello world", remove=True),
+            "alpine", "echo hello world", remove=True
-            b'hello world\n'
+        ) == 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 cm.value.exit_status == 1
-        assert "cat /test" in str(cm.exception)
+        assert "cat /test" in cm.exconly()
-        assert "alpine" in str(cm.exception)
+        assert "alpine" in cm.exconly()
-        assert "No such file or directory" in str(cm.exception)
+        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(
+        assert client.containers.run(
-            client.containers.run(image.id, "cat /test", remove=True),
+            image.id, "cat /test", remove=True
-            b"hello\n"
+        ) == b"hello\n"
-        )
 
     def test_diff(self):
         client = docker.from_env(version=TEST_API_VERSION)

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 (
-        assert str(cm.exception) == (
             "The command '/bin/sh -c exit 1' returned a non-zero code: 1"
-        )
+        ) in cm.exconly()
-        assert cm.exception.build_log
+        assert cm.value.build_log
 
     def test_build_with_multiple_success(self):
         client = docker.from_env(version=TEST_API_VERSION)

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,
+        with pytest.raises(InvalidArgument):
-                               msg='Cannot scale a global container'):
             service.scale(2)
 
         assert len(tasks) == 1

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
+            cm.value.response.status_code == 406 or
-            # https://github.com/docker/docker/issues/29192 is resolved
+            cm.value.response.status_code == 503
-            cm.exception.response.status_code == 406 or
-            cm.exception.response.status_code == 503
         )

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(
+        assert self.client.port(
-            self.client.port(ctnr, 2000)[0]['HostPort'],
+            ctnr, 2000
-            six.text_type(tcp_port)
+        )[0]['HostPort'] == six.text_type(tcp_port)
-        )
+        assert self.client.port(
-        self.assertEqual(
+            ctnr, '2000/tcp'
-            self.client.port(ctnr, '2000/tcp')[0]['HostPort'],
+        )[0]['HostPort'] == six.text_type(tcp_port)
-            six.text_type(tcp_port)
+        assert self.client.port(
-        )
+            ctnr, '2000/udp'
-        self.assertEqual(
+        )[0]['HostPort'] == six.text_type(udp_port)
-            self.client.port(ctnr, '2000/udp')[0]['HostPort'],
-            six.text_type(udp_port)
-        )

tests/unit/api_build_test.py

@@ -5,6 +5,7 @@ import docker
 from docker import auth
 
 from .api_test import BaseAPIClientTest, fake_request, url_prefix
+import pytest
 
 
 class BuildTest(BaseAPIClientTest):
@@ -110,12 +111,10 @@ class BuildTest(BaseAPIClientTest):
         })
 
     def test_build_container_invalid_container_limits(self):
-        self.assertRaises(
+        with pytest.raises(docker.errors.DockerException):
-            docker.errors.DockerException,
+            self.client.build('.', container_limits={
-            lambda: self.client.build('.', container_limits={
                 'foo': 'bar'
             })
-        )
 
     def test_set_auth_headers_with_empty_dict_and_auth_configs(self):
         self.client._auth_configs = {
@@ -130,7 +129,7 @@ class BuildTest(BaseAPIClientTest):
         expected_headers = {
             'X-Registry-Config': auth.encode_header(self.client._auth_configs)}
         self.client._set_auth_headers(headers)
-        self.assertEqual(headers, expected_headers)
+        assert headers == expected_headers
 
     def test_set_auth_headers_with_dict_and_auth_configs(self):
         self.client._auth_configs = {
@@ -147,7 +146,7 @@ class BuildTest(BaseAPIClientTest):
             'X-Registry-Config': auth.encode_header(self.client._auth_configs)}
 
         self.client._set_auth_headers(headers)
-        self.assertEqual(headers, expected_headers)
+        assert headers == expected_headers
 
     def test_set_auth_headers_with_dict_and_no_auth_configs(self):
         headers = {'foo': 'bar'}
@@ -156,4 +155,4 @@ class BuildTest(BaseAPIClientTest):
         }
 
         self.client._set_auth_headers(headers)
-        self.assertEqual(headers, expected_headers)
+        assert headers == expected_headers

tests/unit/api_exec_test.py

@@ -11,15 +11,11 @@ class ExecTest(BaseAPIClientTest):
         self.client.exec_create(fake_api.FAKE_CONTAINER_ID, ['ls', '-1'])
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert 'POST' == args[0][0], url_prefix + 'containers/{0}/exec'.format(
-            'POST',
-            args[0][0], url_prefix + 'containers/{0}/exec'.format(
             fake_api.FAKE_CONTAINER_ID
         )
-        )
 
-        self.assertEqual(
+        assert json.loads(args[1]['data']) == {
-            json.loads(args[1]['data']), {
             'Tty': False,
             'AttachStdout': True,
             'Container': fake_api.FAKE_CONTAINER_ID,
@@ -29,68 +25,52 @@ class ExecTest(BaseAPIClientTest):
             'AttachStderr': True,
             'User': ''
         }
-        )
 
-        self.assertEqual(args[1]['headers'],
+        assert args[1]['headers'] == {'Content-Type': 'application/json'}
-                         {'Content-Type': 'application/json'})
 
     def test_exec_start(self):
         self.client.exec_start(fake_api.FAKE_EXEC_ID)
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == url_prefix + 'exec/{0}/start'.format(
-            args[0][1], url_prefix + 'exec/{0}/start'.format(
             fake_api.FAKE_EXEC_ID
         )
-        )
 
-        self.assertEqual(
+        assert json.loads(args[1]['data']) == {
-            json.loads(args[1]['data']), {
             'Tty': False,
             'Detach': False,
         }
-        )
 
-        self.assertEqual(
+        assert args[1]['headers'] == {
-            args[1]['headers'], {
             'Content-Type': 'application/json',
             'Connection': 'Upgrade',
             'Upgrade': 'tcp'
         }
-        )
 
     def test_exec_start_detached(self):
         self.client.exec_start(fake_api.FAKE_EXEC_ID, detach=True)
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == url_prefix + 'exec/{0}/start'.format(
-            args[0][1], url_prefix + 'exec/{0}/start'.format(
             fake_api.FAKE_EXEC_ID
         )
-        )
 
-        self.assertEqual(
+        assert json.loads(args[1]['data']) == {
-            json.loads(args[1]['data']), {
             'Tty': False,
             'Detach': True
         }
-        )
 
-        self.assertEqual(
+        assert args[1]['headers'] == {
-            args[1]['headers'], {
             'Content-Type': 'application/json'
         }
-        )
 
     def test_exec_inspect(self):
         self.client.exec_inspect(fake_api.FAKE_EXEC_ID)
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == url_prefix + 'exec/{0}/json'.format(
-            args[0][1], url_prefix + 'exec/{0}/json'.format(
             fake_api.FAKE_EXEC_ID
         )
-        )
 
     def test_exec_resize(self):
         self.client.exec_resize(fake_api.FAKE_EXEC_ID, height=20, width=60)

tests/unit/api_image_test.py

@@ -65,29 +65,21 @@ class ImageTest(BaseAPIClientTest):
         self.client.pull('joffrey/test001')
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == url_prefix + 'images/create'
-            args[0][1],
+        assert args[1]['params'] == {
-            url_prefix + 'images/create'
+            'tag': None, 'fromImage': 'joffrey/test001'
-        )
+        }
-        self.assertEqual(
+        assert not args[1]['stream']
-            args[1]['params'],
-            {'tag': None, 'fromImage': 'joffrey/test001'}
-        )
-        self.assertFalse(args[1]['stream'])
 
     def test_pull_stream(self):
         self.client.pull('joffrey/test001', stream=True)
 
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == url_prefix + 'images/create'
-            args[0][1],
+        assert args[1]['params'] == {
-            url_prefix + 'images/create'
+            'tag': None, 'fromImage': 'joffrey/test001'
-        )
+        }
-        self.assertEqual(
+        assert args[1]['stream']
-            args[1]['params'],
-            {'tag': None, 'fromImage': 'joffrey/test001'}
-        )
-        self.assertTrue(args[1]['stream'])
 
     def test_commit(self):
         self.client.commit(fake_api.FAKE_CONTAINER_ID)
@@ -203,18 +195,16 @@ class ImageTest(BaseAPIClientTest):
             with pytest.raises(docker.errors.NullResource) as excinfo:
                 self.client.inspect_image(arg)
 
-            self.assertEqual(
+            assert excinfo.value.args[0] == 'Resource ID was not provided'
-                excinfo.value.args[0], 'Resource ID was not provided'
-            )
 
     def test_insert_image(self):
         try:
             self.client.insert(fake_api.FAKE_IMAGE_NAME,
                                fake_api.FAKE_URL, fake_api.FAKE_PATH)
         except docker.errors.DeprecatedMethod:
-            self.assertTrue(
+            assert docker.utils.compare_version(
-                docker.utils.compare_version('1.12', self.client._version) >= 0
+                '1.12', self.client._version
-            )
+            ) >= 0
             return
 
         fake_request.assert_called_with(

tests/unit/api_network_test.py

@@ -34,20 +34,20 @@ class NetworkTest(BaseAPIClientTest):
             status_code=200, content=json.dumps(networks).encode('utf-8')))
 
         with mock.patch('docker.api.client.APIClient.get', get):
-            self.assertEqual(self.client.networks(), networks)
+            assert self.client.networks() == networks
 
-            self.assertEqual(get.call_args[0][0], url_prefix + 'networks')
+            assert get.call_args[0][0] == url_prefix + 'networks'
 
             filters = json.loads(get.call_args[1]['params']['filters'])
-            self.assertFalse(filters)
+            assert not filters
 
             self.client.networks(names=['foo'])
             filters = json.loads(get.call_args[1]['params']['filters'])
-            self.assertEqual(filters, {'name': ['foo']})
+            assert filters == {'name': ['foo']}
 
             self.client.networks(ids=['123'])
             filters = json.loads(get.call_args[1]['params']['filters'])
-            self.assertEqual(filters, {'id': ['123']})
+            assert filters == {'id': ['123']}
 
     @requires_api_version('1.21')
     def test_create_network(self):
@@ -61,15 +61,11 @@ class NetworkTest(BaseAPIClientTest):
 
         with mock.patch('docker.api.client.APIClient.post', post):
             result = self.client.create_network('foo')
-            self.assertEqual(result, network_data)
+            assert result == network_data
 
-            self.assertEqual(
+            assert post.call_args[0][0] == url_prefix + 'networks/create'
-                post.call_args[0][0],
-                url_prefix + 'networks/create')
 
-            self.assertEqual(
+            assert json.loads(post.call_args[1]['data']) == {"Name": "foo"}
-                json.loads(post.call_args[1]['data']),
-                {"Name": "foo"})
 
             opts = {
                 'com.docker.network.bridge.enable_icc': False,
@@ -77,9 +73,9 @@ class NetworkTest(BaseAPIClientTest):
             }
             self.client.create_network('foo', 'bridge', opts)
 
-            self.assertEqual(
+            assert json.loads(post.call_args[1]['data']) == {
-                json.loads(post.call_args[1]['data']),
+                "Name": "foo", "Driver": "bridge", "Options": opts
-                {"Name": "foo", "Driver": "bridge", "Options": opts})
+            }
 
             ipam_pool_config = IPAMPool(subnet="192.168.52.0/24",
                                         gateway="192.168.52.254")
@@ -88,9 +84,7 @@ class NetworkTest(BaseAPIClientTest):
             self.client.create_network("bar", driver="bridge",
                                        ipam=ipam_config)
 
-            self.assertEqual(
+            assert json.loads(post.call_args[1]['data']) == {
-                json.loads(post.call_args[1]['data']),
-                {
                 "Name": "bar",
                 "Driver": "bridge",
                 "IPAM": {
@@ -102,7 +96,7 @@ class NetworkTest(BaseAPIClientTest):
                         "AuxiliaryAddresses": None,
                     }],
                 }
-                })
+            }
 
     @requires_api_version('1.21')
     def test_remove_network(self):
@@ -113,8 +107,7 @@ class NetworkTest(BaseAPIClientTest):
             self.client.remove_network(network_id)
 
         args = delete.call_args
-        self.assertEqual(args[0][0],
+        assert args[0][0] == url_prefix + 'networks/{0}'.format(network_id)
-                         url_prefix + 'networks/{0}'.format(network_id))
 
     @requires_api_version('1.21')
     def test_inspect_network(self):
@@ -132,11 +125,10 @@ class NetworkTest(BaseAPIClientTest):
 
         with mock.patch('docker.api.client.APIClient.get', get):
             result = self.client.inspect_network(network_id)
-            self.assertEqual(result, network_data)
+            assert result == network_data
 
         args = get.call_args
-        self.assertEqual(args[0][0],
+        assert args[0][0] == url_prefix + 'networks/{0}'.format(network_id)
-                         url_prefix + 'networks/{0}'.format(network_id))
 
     @requires_api_version('1.21')
     def test_connect_container_to_network(self):
@@ -153,19 +145,17 @@ class NetworkTest(BaseAPIClientTest):
                 links=[('baz', 'quux')]
             )
 
-        self.assertEqual(
+        assert post.call_args[0][0] == (
-            post.call_args[0][0],
+            url_prefix + 'networks/{0}/connect'.format(network_id)
-            url_prefix + 'networks/{0}/connect'.format(network_id))
+        )
 
-        self.assertEqual(
+        assert json.loads(post.call_args[1]['data']) == {
-            json.loads(post.call_args[1]['data']),
-            {
             'Container': container_id,
             'EndpointConfig': {
                 'Aliases': ['foo', 'bar'],
                 'Links': ['baz:quux'],
             },
-            })
+        }
 
     @requires_api_version('1.21')
     def test_disconnect_container_from_network(self):
@@ -178,10 +168,9 @@ class NetworkTest(BaseAPIClientTest):
             self.client.disconnect_container_from_network(
                 container={'Id': container_id}, net_id=network_id)
 
-        self.assertEqual(
+        assert post.call_args[0][0] == (
-            post.call_args[0][0],
+            url_prefix + 'networks/{0}/disconnect'.format(network_id)
-            url_prefix + 'networks/{0}/disconnect'.format(network_id))
+        )
-
+        assert json.loads(post.call_args[1]['data']) == {
-        self.assertEqual(
+            'Container': container_id
-            json.loads(post.call_args[1]['data']),
+        }
-            {'Container': container_id})

tests/unit/api_test.py

@@ -128,34 +128,27 @@ class DockerApiTest(BaseAPIClientTest):
         with pytest.raises(docker.errors.DockerException) as excinfo:
             APIClient(version=1.12)
 
-        self.assertEqual(
+        assert str(
-            str(excinfo.value),
+            excinfo.value
-            'Version parameter must be a string or None. Found float'
+        ) == 'Version parameter must be a string or None. Found float'
-        )
 
     def test_url_valid_resource(self):
         url = self.client._url('/hello/{0}/world', 'somename')
-        self.assertEqual(
+        assert url == '{0}{1}'.format(url_prefix, 'hello/somename/world')
-            url, '{0}{1}'.format(url_prefix, 'hello/somename/world')
-        )
 
         url = self.client._url(
             '/hello/{0}/world/{1}', 'somename', 'someothername'
         )
-        self.assertEqual(
+        assert url == '{0}{1}'.format(
-            url,
+            url_prefix, 'hello/somename/world/someothername'
-            '{0}{1}'.format(url_prefix, 'hello/somename/world/someothername')
         )
 
         url = self.client._url('/hello/{0}/world', 'some?name')
-        self.assertEqual(
+        assert url == '{0}{1}'.format(url_prefix, 'hello/some%3Fname/world')
-            url, '{0}{1}'.format(url_prefix, 'hello/some%3Fname/world')
-        )
 
         url = self.client._url("/images/{0}/push", "localhost:5000/image")
-        self.assertEqual(
+        assert url == '{0}{1}'.format(
-            url,
+            url_prefix, 'images/localhost:5000/image/push'
-            '{0}{1}'.format(url_prefix, 'images/localhost:5000/image/push')
         )
 
     def test_url_invalid_resource(self):
@@ -164,15 +157,13 @@ class DockerApiTest(BaseAPIClientTest):
 
     def test_url_no_resource(self):
         url = self.client._url('/simple')
-        self.assertEqual(url, '{0}{1}'.format(url_prefix, 'simple'))
+        assert url == '{0}{1}'.format(url_prefix, 'simple')
 
     def test_url_unversioned_api(self):
         url = self.client._url(
             '/hello/{0}/world', 'somename', versioned_api=False
         )
-        self.assertEqual(
+        assert url == '{0}{1}'.format(url_base, 'hello/somename/world')
-            url, '{0}{1}'.format(url_base, 'hello/somename/world')
-        )
 
     def test_version(self):
         self.client.version()
@@ -194,13 +185,13 @@ class DockerApiTest(BaseAPIClientTest):
 
     def test_retrieve_server_version(self):
         client = APIClient(version="auto")
-        self.assertTrue(isinstance(client._version, six.string_types))
+        assert isinstance(client._version, six.string_types)
-        self.assertFalse(client._version == "auto")
+        assert not (client._version == "auto")
         client.close()
 
     def test_auto_retrieve_server_version(self):
         version = self.client._retrieve_server_version()
-        self.assertTrue(isinstance(version, six.string_types))
+        assert isinstance(version, six.string_types)
 
     def test_info(self):
         self.client.info()
@@ -313,11 +304,10 @@ class DockerApiTest(BaseAPIClientTest):
     def test_create_host_config_secopt(self):
         security_opt = ['apparmor:test_profile']
         result = self.client.create_host_config(security_opt=security_opt)
-        self.assertIn('SecurityOpt', result)
+        assert 'SecurityOpt' in result
-        self.assertEqual(result['SecurityOpt'], security_opt)
+        assert result['SecurityOpt'] == security_opt
-        self.assertRaises(
+        with pytest.raises(TypeError):
-            TypeError, self.client.create_host_config, security_opt='wrong'
+            self.client.create_host_config(security_opt='wrong')
-        )
 
     def test_stream_helper_decoding(self):
         status_code, content = fake_api.fake_responses[url_prefix + 'events']()
@@ -335,26 +325,26 @@ class DockerApiTest(BaseAPIClientTest):
         raw_resp._fp.seek(0)
         resp = response(status_code=status_code, content=content, raw=raw_resp)
         result = next(self.client._stream_helper(resp))
-        self.assertEqual(result, content_str)
+        assert result == content_str
 
         # pass `decode=True` to the helper
         raw_resp._fp.seek(0)
         resp = response(status_code=status_code, content=content, raw=raw_resp)
         result = next(self.client._stream_helper(resp, decode=True))
-        self.assertEqual(result, content)
+        assert result == content
 
         # non-chunked response, pass `decode=False` to the helper
         setattr(raw_resp._fp, 'chunked', False)
         raw_resp._fp.seek(0)
         resp = response(status_code=status_code, content=content, raw=raw_resp)
         result = next(self.client._stream_helper(resp))
-        self.assertEqual(result, content_str.decode('utf-8'))
+        assert result == content_str.decode('utf-8')
 
         # non-chunked response, pass `decode=True` to the helper
         raw_resp._fp.seek(0)
         resp = response(status_code=status_code, content=content, raw=raw_resp)
         result = next(self.client._stream_helper(resp, decode=True))
-        self.assertEqual(result, content)
+        assert result == content
 
 
 class StreamTest(unittest.TestCase):
@@ -442,8 +432,7 @@ class StreamTest(unittest.TestCase):
             b'\r\n'
         ) + b'\r\n'.join(lines)
 
-        with APIClient(base_url="http+unix://" + self.socket_file) \
+        with APIClient(base_url="http+unix://" + self.socket_file) as client:
-                as client:
             for i in range(5):
                 try:
                     stream = client.build(
@@ -455,8 +444,8 @@ class StreamTest(unittest.TestCase):
                     if i == 4:
                         raise e
 
-            self.assertEqual(list(stream), [
+            assert list(stream) == [
-                str(i).encode() for i in range(50)])
+                str(i).encode() for i in range(50)]
 
 
 class UserAgentTest(unittest.TestCase):
@@ -475,18 +464,18 @@ class UserAgentTest(unittest.TestCase):
         client = APIClient()
         client.version()
 
-        self.assertEqual(self.mock_send.call_count, 1)
+        assert self.mock_send.call_count == 1
         headers = self.mock_send.call_args[0][0].headers
         expected = 'docker-sdk-python/%s' % docker.__version__
-        self.assertEqual(headers['User-Agent'], expected)
+        assert headers['User-Agent'] == expected
 
     def test_custom_user_agent(self):
         client = APIClient(user_agent='foo/bar')
         client.version()
 
-        self.assertEqual(self.mock_send.call_count, 1)
+        assert self.mock_send.call_count == 1
         headers = self.mock_send.call_args[0][0].headers
-        self.assertEqual(headers['User-Agent'], 'foo/bar')
+        assert headers['User-Agent'] == 'foo/bar'
 
 
 class DisableSocketTest(unittest.TestCase):
@@ -509,7 +498,7 @@ class DisableSocketTest(unittest.TestCase):
 
         self.client._disable_socket_timeout(socket)
 
-        self.assertEqual(socket.timeout, None)
+        assert socket.timeout is None
 
     def test_disable_socket_timeout2(self):
         """Test that the timeouts are disabled on a generic socket object
@@ -519,8 +508,8 @@ class DisableSocketTest(unittest.TestCase):
 
         self.client._disable_socket_timeout(socket)
 
-        self.assertEqual(socket.timeout, None)
+        assert socket.timeout is None
-        self.assertEqual(socket._sock.timeout, None)
+        assert socket._sock.timeout is None
 
     def test_disable_socket_timout_non_blocking(self):
         """Test that a non-blocking socket does not get set to blocking."""
@@ -529,5 +518,5 @@ class DisableSocketTest(unittest.TestCase):
 
         self.client._disable_socket_timeout(socket)
 
-        self.assertEqual(socket.timeout, None)
+        assert socket.timeout is None
-        self.assertEqual(socket._sock.timeout, 0.0)
+        assert socket._sock.timeout == 0.0

tests/unit/api_volume_test.py

@@ -10,12 +10,12 @@ class VolumeTest(BaseAPIClientTest):
     @requires_api_version('1.21')
     def test_list_volumes(self):
         volumes = self.client.volumes()
-        self.assertIn('Volumes', volumes)
+        assert 'Volumes' in volumes
-        self.assertEqual(len(volumes['Volumes']), 2)
+        assert len(volumes['Volumes']) == 2
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'GET')
+        assert args[0][0] == 'GET'
-        self.assertEqual(args[0][1], url_prefix + 'volumes')
+        assert args[0][1] == url_prefix + 'volumes'
 
     @requires_api_version('1.21')
     def test_list_volumes_and_filters(self):
@@ -33,25 +33,25 @@ class VolumeTest(BaseAPIClientTest):
     def test_create_volume(self):
         name = 'perfectcherryblossom'
         result = self.client.create_volume(name)
-        self.assertIn('Name', result)
+        assert 'Name' in result
-        self.assertEqual(result['Name'], name)
+        assert result['Name'] == name
-        self.assertIn('Driver', result)
+        assert 'Driver' in result
-        self.assertEqual(result['Driver'], 'local')
+        assert result['Driver'] == 'local'
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'POST')
+        assert args[0][0] == 'POST'
-        self.assertEqual(args[0][1], url_prefix + 'volumes/create')
+        assert args[0][1] == url_prefix + 'volumes/create'
-        self.assertEqual(json.loads(args[1]['data']), {'Name': name})
+        assert json.loads(args[1]['data']) == {'Name': name}
 
     @requires_api_version('1.23')
     def test_create_volume_with_labels(self):
         name = 'perfectcherryblossom'
         result = self.client.create_volume(name, labels={
-            'com.example.some-label': 'some-value'})
+            'com.example.some-label': 'some-value'
-        self.assertEqual(
+        })
-            result["Labels"],
+        assert result["Labels"] == {
-            {'com.example.some-label': 'some-value'}
+            'com.example.some-label': 'some-value'
-        )
+        }
 
     @requires_api_version('1.23')
     def test_create_volume_with_invalid_labels(self):
@@ -66,11 +66,11 @@ class VolumeTest(BaseAPIClientTest):
         self.client.create_volume(name, driver=driver_name)
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'POST')
+        assert args[0][0] == 'POST'
-        self.assertEqual(args[0][1], url_prefix + 'volumes/create')
+        assert args[0][1] == url_prefix + 'volumes/create'
         data = json.loads(args[1]['data'])
-        self.assertIn('Driver', data)
+        assert 'Driver' in data
-        self.assertEqual(data['Driver'], driver_name)
+        assert data['Driver'] == driver_name
 
     @requires_api_version('1.21')
     def test_create_volume_invalid_opts_type(self):
@@ -92,25 +92,25 @@ class VolumeTest(BaseAPIClientTest):
     @requires_api_version('1.24')
     def test_create_volume_with_no_specified_name(self):
         result = self.client.create_volume(name=None)
-        self.assertIn('Name', result)
+        assert 'Name' in result
-        self.assertNotEqual(result['Name'], None)
+        assert result['Name'] is not None
-        self.assertIn('Driver', result)
+        assert 'Driver' in result
-        self.assertEqual(result['Driver'], 'local')
+        assert result['Driver'] == 'local'
-        self.assertIn('Scope', result)
+        assert 'Scope' in result
-        self.assertEqual(result['Scope'], 'local')
+        assert result['Scope'] == 'local'
 
     @requires_api_version('1.21')
     def test_inspect_volume(self):
         name = 'perfectcherryblossom'
         result = self.client.inspect_volume(name)
-        self.assertIn('Name', result)
+        assert 'Name' in result
-        self.assertEqual(result['Name'], name)
+        assert result['Name'] == name
-        self.assertIn('Driver', result)
+        assert 'Driver' in result
-        self.assertEqual(result['Driver'], 'local')
+        assert result['Driver'] == 'local'
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'GET')
+        assert args[0][0] == 'GET'
-        self.assertEqual(args[0][1], '{0}volumes/{1}'.format(url_prefix, name))
+        assert args[0][1] == '{0}volumes/{1}'.format(url_prefix, name)
 
     @requires_api_version('1.21')
     def test_remove_volume(self):
@@ -118,5 +118,5 @@ class VolumeTest(BaseAPIClientTest):
         self.client.remove_volume(name)
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'DELETE')
+        assert args[0][0] == 'DELETE'
-        self.assertEqual(args[0][1], '{0}volumes/{1}'.format(url_prefix, name))
+        assert args[0][1] == '{0}volumes/{1}'.format(url_prefix, name)

tests/unit/auth_test.py

@@ -13,6 +13,7 @@ from py.test import ensuretemp
 from pytest import mark
 
 from docker import auth, errors
+import pytest
 
 try:
     from unittest import mock
@@ -33,82 +34,68 @@ class RegressionTest(unittest.TestCase):
 
 class ResolveRepositoryNameTest(unittest.TestCase):
     def test_resolve_repository_name_hub_library_image(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('image') == (
-            auth.resolve_repository_name('image'),
+            'docker.io', 'image'
-            ('docker.io', 'image'),
         )
 
     def test_resolve_repository_name_dotted_hub_library_image(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('image.valid') == (
-            auth.resolve_repository_name('image.valid'),
+            'docker.io', 'image.valid'
-            ('docker.io', 'image.valid')
         )
 
     def test_resolve_repository_name_hub_image(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('username/image') == (
-            auth.resolve_repository_name('username/image'),
+            'docker.io', 'username/image'
-            ('docker.io', 'username/image'),
         )
 
     def test_explicit_hub_index_library_image(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('docker.io/image') == (
-            auth.resolve_repository_name('docker.io/image'),
+            'docker.io', 'image'
-            ('docker.io', 'image')
         )
 
     def test_explicit_legacy_hub_index_library_image(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('index.docker.io/image') == (
-            auth.resolve_repository_name('index.docker.io/image'),
+            'docker.io', 'image'
-            ('docker.io', 'image')
         )
 
     def test_resolve_repository_name_private_registry(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('my.registry.net/image') == (
-            auth.resolve_repository_name('my.registry.net/image'),
+            'my.registry.net', 'image'
-            ('my.registry.net', 'image'),
         )
 
     def test_resolve_repository_name_private_registry_with_port(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('my.registry.net:5000/image') == (
-            auth.resolve_repository_name('my.registry.net:5000/image'),
+            'my.registry.net:5000', 'image'
-            ('my.registry.net:5000', 'image'),
         )
 
     def test_resolve_repository_name_private_registry_with_username(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name(
-            auth.resolve_repository_name('my.registry.net/username/image'),
+            'my.registry.net/username/image'
-            ('my.registry.net', 'username/image'),
+        ) == ('my.registry.net', 'username/image')
-        )
 
     def test_resolve_repository_name_no_dots_but_port(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('hostname:5000/image') == (
-            auth.resolve_repository_name('hostname:5000/image'),
+            'hostname:5000', 'image'
-            ('hostname:5000', 'image'),
         )
 
     def test_resolve_repository_name_no_dots_but_port_and_username(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name(
-            auth.resolve_repository_name('hostname:5000/username/image'),
+            'hostname:5000/username/image'
-            ('hostname:5000', 'username/image'),
+        ) == ('hostname:5000', 'username/image')
-        )
 
     def test_resolve_repository_name_localhost(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('localhost/image') == (
-            auth.resolve_repository_name('localhost/image'),
+            'localhost', 'image'
-            ('localhost', 'image'),
         )
 
     def test_resolve_repository_name_localhost_with_username(self):
-        self.assertEqual(
+        assert auth.resolve_repository_name('localhost/username/image') == (
-            auth.resolve_repository_name('localhost/username/image'),
+            'localhost', 'username/image'
-            ('localhost', 'username/image'),
         )
 
     def test_invalid_index_name(self):
-        self.assertRaises(
+        with pytest.raises(errors.InvalidRepository):
-            errors.InvalidRepository,
+            auth.resolve_repository_name('-gecko.com/image')
-            lambda: auth.resolve_repository_name('-gecko.com/image')
-        )
 
 
 def encode_auth(auth_info):
@@ -129,147 +116,100 @@ class ResolveAuthTest(unittest.TestCase):
     })
 
     def test_resolve_authconfig_hostname_only(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'my.registry.net'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_no_protocol(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'my.registry.net/v1/'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_no_path(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'http://my.registry.net'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_no_path_trailing_slash(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'http://my.registry.net/'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_no_path_wrong_secure_proto(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'https://my.registry.net'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_no_path_wrong_insecure_proto(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'http://index.docker.io'
-            )['username'],
+        )['username'] == 'indexuser'
-            'indexuser'
-        )
 
     def test_resolve_authconfig_path_wrong_proto(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'https://my.registry.net/v1/'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_default_registry(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(self.auth_config)['username'],
+            self.auth_config
-            'indexuser'
+        )['username'] == 'indexuser'
-        )
 
     def test_resolve_authconfig_default_explicit_none(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(self.auth_config, None)['username'],
+            self.auth_config, None
-            'indexuser'
+        )['username'] == 'indexuser'
-        )
 
     def test_resolve_authconfig_fully_explicit(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'http://my.registry.net/v1/'
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser'
-        )
 
     def test_resolve_authconfig_legacy_config(self):
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, 'legacy.registry.url'
-            )['username'],
+        )['username'] == 'legacyauth'
-            'legacyauth'
-        )
 
     def test_resolve_authconfig_no_match(self):
-        self.assertTrue(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(self.auth_config, 'does.not.exist') is None
+            self.auth_config, 'does.not.exist'
-        )
+        ) is None
 
     def test_resolve_registry_and_auth_library_image(self):
         image = 'image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            )['username'],
+        )['username'] == 'indexuser'
-            'indexuser',
-        )
 
     def test_resolve_registry_and_auth_hub_image(self):
         image = 'username/image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            )['username'],
+        )['username'] == 'indexuser'
-            'indexuser',
-        )
 
     def test_resolve_registry_and_auth_explicit_hub(self):
         image = 'docker.io/username/image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            )['username'],
+        )['username'] == 'indexuser'
-            'indexuser',
-        )
 
     def test_resolve_registry_and_auth_explicit_legacy_hub(self):
         image = 'index.docker.io/username/image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            )['username'],
+        )['username'] == 'indexuser'
-            'indexuser',
-        )
 
     def test_resolve_registry_and_auth_private_registry(self):
         image = 'my.registry.net/image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            )['username'],
+        )['username'] == 'privateuser'
-            'privateuser',
-        )
 
     def test_resolve_registry_and_auth_unauthenticated_registry(self):
         image = 'other.registry.net/image'
-        self.assertEqual(
+        assert auth.resolve_authconfig(
-            auth.resolve_authconfig(
             self.auth_config, auth.resolve_repository_name(image)[0]
-            ),
+        ) is None
-            None,
-        )
 
 
 class CredStoreTest(unittest.TestCase):
@@ -378,7 +318,7 @@ class LoadConfigTest(unittest.TestCase):
         folder = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, folder)
         cfg = auth.load_config(folder)
-        self.assertTrue(cfg is not None)
+        assert cfg is not None
 
     def test_load_config(self):
         folder = tempfile.mkdtemp()
@@ -390,12 +330,12 @@ class LoadConfigTest(unittest.TestCase):
             f.write('email = sakuya@scarlet.net')
         cfg = auth.load_config(dockercfg_path)
         assert auth.INDEX_NAME in cfg
-        self.assertNotEqual(cfg[auth.INDEX_NAME], None)
+        assert cfg[auth.INDEX_NAME] is not None
         cfg = cfg[auth.INDEX_NAME]
-        self.assertEqual(cfg['username'], 'sakuya')
+        assert cfg['username'] == 'sakuya'
-        self.assertEqual(cfg['password'], 'izayoi')
+        assert cfg['password'] == 'izayoi'
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+        assert cfg['email'] == 'sakuya@scarlet.net'
-        self.assertEqual(cfg.get('auth'), None)
+        assert cfg.get('auth') is None
 
     def test_load_config_with_random_name(self):
         folder = tempfile.mkdtemp()
@@ -418,12 +358,12 @@ class LoadConfigTest(unittest.TestCase):
 
         cfg = auth.load_config(dockercfg_path)
         assert registry in cfg
-        self.assertNotEqual(cfg[registry], None)
+        assert cfg[registry] is not None
         cfg = cfg[registry]
-        self.assertEqual(cfg['username'], 'sakuya')
+        assert cfg['username'] == 'sakuya'
-        self.assertEqual(cfg['password'], 'izayoi')
+        assert cfg['password'] == 'izayoi'
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+        assert cfg['email'] == 'sakuya@scarlet.net'
-        self.assertEqual(cfg.get('auth'), None)
+        assert cfg.get('auth') is None
 
     def test_load_config_custom_config_env(self):
         folder = tempfile.mkdtemp()
@@ -445,12 +385,12 @@ class LoadConfigTest(unittest.TestCase):
         with mock.patch.dict(os.environ, {'DOCKER_CONFIG': folder}):
             cfg = auth.load_config(None)
             assert registry in cfg
-            self.assertNotEqual(cfg[registry], None)
+            assert cfg[registry] is not None
             cfg = cfg[registry]
-            self.assertEqual(cfg['username'], 'sakuya')
+            assert cfg['username'] == 'sakuya'
-            self.assertEqual(cfg['password'], 'izayoi')
+            assert cfg['password'] == 'izayoi'
-            self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+            assert cfg['email'] == 'sakuya@scarlet.net'
-            self.assertEqual(cfg.get('auth'), None)
+            assert cfg.get('auth') is None
 
     def test_load_config_custom_config_env_with_auths(self):
         folder = tempfile.mkdtemp()
@@ -474,12 +414,12 @@ class LoadConfigTest(unittest.TestCase):
         with mock.patch.dict(os.environ, {'DOCKER_CONFIG': folder}):
             cfg = auth.load_config(None)
             assert registry in cfg
-            self.assertNotEqual(cfg[registry], None)
+            assert cfg[registry] is not None
             cfg = cfg[registry]
-            self.assertEqual(cfg['username'], 'sakuya')
+            assert cfg['username'] == 'sakuya'
-            self.assertEqual(cfg['password'], 'izayoi')
+            assert cfg['password'] == 'izayoi'
-            self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+            assert cfg['email'] == 'sakuya@scarlet.net'
-            self.assertEqual(cfg.get('auth'), None)
+            assert cfg.get('auth') is None
 
     def test_load_config_custom_config_env_utf8(self):
         folder = tempfile.mkdtemp()
@@ -504,12 +444,12 @@ class LoadConfigTest(unittest.TestCase):
         with mock.patch.dict(os.environ, {'DOCKER_CONFIG': folder}):
             cfg = auth.load_config(None)
             assert registry in cfg
-            self.assertNotEqual(cfg[registry], None)
+            assert cfg[registry] is not None
             cfg = cfg[registry]
-            self.assertEqual(cfg['username'], b'sakuya\xc3\xa6'.decode('utf8'))
+            assert cfg['username'] == b'sakuya\xc3\xa6'.decode('utf8')
-            self.assertEqual(cfg['password'], b'izayoi\xc3\xa6'.decode('utf8'))
+            assert cfg['password'] == b'izayoi\xc3\xa6'.decode('utf8')
-            self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
+            assert cfg['email'] == 'sakuya@scarlet.net'
-            self.assertEqual(cfg.get('auth'), None)
+            assert cfg.get('auth') is None
 
     def test_load_config_custom_config_env_with_headers(self):
         folder = tempfile.mkdtemp()
@@ -529,11 +469,11 @@ class LoadConfigTest(unittest.TestCase):
         with mock.patch.dict(os.environ, {'DOCKER_CONFIG': folder}):
             cfg = auth.load_config(None)
             assert 'HttpHeaders' in cfg
-            self.assertNotEqual(cfg['HttpHeaders'], None)
+            assert cfg['HttpHeaders'] is not None
             cfg = cfg['HttpHeaders']
 
-            self.assertEqual(cfg['Name'], 'Spike')
+            assert cfg['Name'] == 'Spike'
-            self.assertEqual(cfg['Surname'], 'Spiegel')
+            assert cfg['Surname'] == 'Spiegel'
 
     def test_load_config_unknown_keys(self):
         folder = tempfile.mkdtemp()

tests/unit/client_test.py

@@ -8,6 +8,7 @@ import os
 import unittest
 
 from . import fake_api
+import pytest
 
 try:
     from unittest import mock
@@ -51,25 +52,25 @@ class ClientTest(unittest.TestCase):
 
     def test_call_api_client_method(self):
         client = docker.from_env()
-        with self.assertRaises(AttributeError) as cm:
+        with pytest.raises(AttributeError) as cm:
             client.create_container()
-        s = str(cm.exception)
+        s = cm.exconly()
         assert "'DockerClient' object has no attribute 'create_container'" in s
         assert "this method is now on the object APIClient" in s
 
-        with self.assertRaises(AttributeError) as cm:
+        with pytest.raises(AttributeError) as cm:
             client.abcdef()
-        s = str(cm.exception)
+        s = cm.exconly()
         assert "'DockerClient' object has no attribute 'abcdef'" in s
         assert "this method is now on the object APIClient" not in s
 
     def test_call_containers(self):
         client = docker.DockerClient(**kwargs_from_env())
 
-        with self.assertRaises(TypeError) as cm:
+        with pytest.raises(TypeError) as cm:
             client.containers()
 
-        s = str(cm.exception)
+        s = cm.exconly()
         assert "'ContainerCollection' object is not callable" in s
         assert "docker.APIClient" in s
 
@@ -90,22 +91,22 @@ class FromEnvTest(unittest.TestCase):
                           DOCKER_CERT_PATH=TEST_CERT_DIR,
                           DOCKER_TLS_VERIFY='1')
         client = docker.from_env()
-        self.assertEqual(client.api.base_url, "https://192.168.59.103:2376")
+        assert client.api.base_url == "https://192.168.59.103:2376"
 
     def test_from_env_with_version(self):
         os.environ.update(DOCKER_HOST='tcp://192.168.59.103:2376',
                           DOCKER_CERT_PATH=TEST_CERT_DIR,
                           DOCKER_TLS_VERIFY='1')
         client = docker.from_env(version='2.32')
-        self.assertEqual(client.api.base_url, "https://192.168.59.103:2376")
+        assert client.api.base_url == "https://192.168.59.103:2376"
-        self.assertEqual(client.api._version, '2.32')
+        assert client.api._version == '2.32'
 
     def test_from_env_without_version_uses_default(self):
         client = docker.from_env()
 
-        self.assertEqual(client.api._version, DEFAULT_DOCKER_API_VERSION)
+        assert client.api._version == DEFAULT_DOCKER_API_VERSION
 
     def test_from_env_without_timeout_uses_default(self):
         client = docker.from_env()
 
-        self.assertEqual(client.api.timeout, DEFAULT_TIMEOUT_SECONDS)
+        assert client.api.timeout == DEFAULT_TIMEOUT_SECONDS

tests/unit/dockertypes_test.py

@@ -25,11 +25,11 @@ def create_host_config(*args, **kwargs):
 class HostConfigTest(unittest.TestCase):
     def test_create_host_config_no_options(self):
         config = create_host_config(version='1.19')
-        self.assertFalse('NetworkMode' in config)
+        assert not ('NetworkMode' in config)
 
     def test_create_host_config_no_options_newer_api_version(self):
         config = create_host_config(version='1.20')
-        self.assertEqual(config['NetworkMode'], 'default')
+        assert config['NetworkMode'] == 'default'
 
     def test_create_host_config_invalid_cpu_cfs_types(self):
         with pytest.raises(TypeError):
@@ -46,65 +46,58 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_cpu_quota(self):
         config = create_host_config(version='1.20', cpu_quota=1999)
-        self.assertEqual(config.get('CpuQuota'), 1999)
+        assert config.get('CpuQuota') == 1999
 
     def test_create_host_config_with_cpu_period(self):
         config = create_host_config(version='1.20', cpu_period=1999)
-        self.assertEqual(config.get('CpuPeriod'), 1999)
+        assert config.get('CpuPeriod') == 1999
 
     def test_create_host_config_with_blkio_constraints(self):
         blkio_rate = [{"Path": "/dev/sda", "Rate": 1000}]
-        config = create_host_config(version='1.22',
+        config = create_host_config(
-                                    blkio_weight=1999,
+            version='1.22', blkio_weight=1999, blkio_weight_device=blkio_rate,
-                                    blkio_weight_device=blkio_rate,
+            device_read_bps=blkio_rate, device_write_bps=blkio_rate,
-                                    device_read_bps=blkio_rate,
+            device_read_iops=blkio_rate, device_write_iops=blkio_rate
-                                    device_write_bps=blkio_rate,
+        )
-                                    device_read_iops=blkio_rate,
-                                    device_write_iops=blkio_rate)
 
-        self.assertEqual(config.get('BlkioWeight'), 1999)
+        assert config.get('BlkioWeight') == 1999
-        self.assertTrue(config.get('BlkioWeightDevice') is blkio_rate)
+        assert config.get('BlkioWeightDevice') is blkio_rate
-        self.assertTrue(config.get('BlkioDeviceReadBps') is blkio_rate)
+        assert config.get('BlkioDeviceReadBps') is blkio_rate
-        self.assertTrue(config.get('BlkioDeviceWriteBps') is blkio_rate)
+        assert config.get('BlkioDeviceWriteBps') is blkio_rate
-        self.assertTrue(config.get('BlkioDeviceReadIOps') is blkio_rate)
+        assert config.get('BlkioDeviceReadIOps') is blkio_rate
-        self.assertTrue(config.get('BlkioDeviceWriteIOps') is blkio_rate)
+        assert config.get('BlkioDeviceWriteIOps') is blkio_rate
-        self.assertEqual(blkio_rate[0]['Path'], "/dev/sda")
+        assert blkio_rate[0]['Path'] == "/dev/sda"
-        self.assertEqual(blkio_rate[0]['Rate'], 1000)
+        assert blkio_rate[0]['Rate'] == 1000
 
     def test_create_host_config_with_shm_size(self):
         config = create_host_config(version='1.22', shm_size=67108864)
-        self.assertEqual(config.get('ShmSize'), 67108864)
+        assert config.get('ShmSize') == 67108864
 
     def test_create_host_config_with_shm_size_in_mb(self):
         config = create_host_config(version='1.22', shm_size='64M')
-        self.assertEqual(config.get('ShmSize'), 67108864)
+        assert config.get('ShmSize') == 67108864
 
     def test_create_host_config_with_oom_kill_disable(self):
         config = create_host_config(version='1.20', oom_kill_disable=True)
-        self.assertEqual(config.get('OomKillDisable'), True)
+        assert config.get('OomKillDisable') is True
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(version='1.18.3',
+            create_host_config(version='1.18.3', oom_kill_disable=True)
-                                                       oom_kill_disable=True))
 
     def test_create_host_config_with_userns_mode(self):
         config = create_host_config(version='1.23', userns_mode='host')
-        self.assertEqual(config.get('UsernsMode'), 'host')
+        assert config.get('UsernsMode') == 'host'
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(version='1.22',
+            create_host_config(version='1.22', userns_mode='host')
-                                                       userns_mode='host'))
+        with pytest.raises(ValueError):
-        self.assertRaises(
+            create_host_config(version='1.23', userns_mode='host12')
-            ValueError, lambda: create_host_config(version='1.23',
-                                                   userns_mode='host12'))
 
     def test_create_host_config_with_oom_score_adj(self):
         config = create_host_config(version='1.22', oom_score_adj=100)
-        self.assertEqual(config.get('OomScoreAdj'), 100)
+        assert config.get('OomScoreAdj') == 100
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(version='1.21',
+            create_host_config(version='1.21', oom_score_adj=100)
-                                                       oom_score_adj=100))
+        with pytest.raises(TypeError):
-        self.assertRaises(
+            create_host_config(version='1.22', oom_score_adj='100')
-            TypeError, lambda: create_host_config(version='1.22',
-                                                  oom_score_adj='100'))
 
     def test_create_host_config_with_dns_opt(self):
 
@@ -112,30 +105,27 @@ class HostConfigTest(unittest.TestCase):
         config = create_host_config(version='1.21', dns_opt=tested_opts)
         dns_opts = config.get('DnsOptions')
 
-        self.assertTrue('use-vc' in dns_opts)
+        assert 'use-vc' in dns_opts
-        self.assertTrue('no-tld-query' in dns_opts)
+        assert 'no-tld-query' in dns_opts
 
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(version='1.20',
+            create_host_config(version='1.20', dns_opt=tested_opts)
-                                                       dns_opt=tested_opts))
 
     def test_create_host_config_with_mem_reservation(self):
         config = create_host_config(version='1.21', mem_reservation=67108864)
-        self.assertEqual(config.get('MemoryReservation'), 67108864)
+        assert config.get('MemoryReservation') == 67108864
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.20', mem_reservation=67108864)
-                version='1.20', mem_reservation=67108864))
 
     def test_create_host_config_with_kernel_memory(self):
         config = create_host_config(version='1.21', kernel_memory=67108864)
-        self.assertEqual(config.get('KernelMemory'), 67108864)
+        assert config.get('KernelMemory') == 67108864
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.20', kernel_memory=67108864)
-                version='1.20', kernel_memory=67108864))
 
     def test_create_host_config_with_pids_limit(self):
         config = create_host_config(version='1.23', pids_limit=1024)
-        self.assertEqual(config.get('PidsLimit'), 1024)
+        assert config.get('PidsLimit') == 1024
 
         with pytest.raises(InvalidVersion):
             create_host_config(version='1.22', pids_limit=1024)
@@ -144,7 +134,7 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_isolation(self):
         config = create_host_config(version='1.24', isolation='hyperv')
-        self.assertEqual(config.get('Isolation'), 'hyperv')
+        assert config.get('Isolation') == 'hyperv'
 
         with pytest.raises(InvalidVersion):
             create_host_config(version='1.23', isolation='hyperv')
@@ -179,10 +169,9 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_cpu_count(self):
         config = create_host_config(version='1.25', cpu_count=2)
-        self.assertEqual(config.get('CpuCount'), 2)
+        assert config.get('CpuCount') == 2
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.24', cpu_count=1)
-                version='1.24', cpu_count=1))
 
     def test_create_host_config_invalid_cpu_percent_types(self):
         with pytest.raises(TypeError):
@@ -190,10 +179,9 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_cpu_percent(self):
         config = create_host_config(version='1.25', cpu_percent=15)
-        self.assertEqual(config.get('CpuPercent'), 15)
+        assert config.get('CpuPercent') == 15
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.24', cpu_percent=10)
-                version='1.24', cpu_percent=10))
 
     def test_create_host_config_invalid_nano_cpus_types(self):
         with pytest.raises(TypeError):
@@ -201,10 +189,9 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_nano_cpus(self):
         config = create_host_config(version='1.25', nano_cpus=1000)
-        self.assertEqual(config.get('NanoCpus'), 1000)
+        assert config.get('NanoCpus') == 1000
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.24', nano_cpus=1)
-                version='1.24', nano_cpus=1))
 
     def test_create_host_config_with_cpu_rt_period_types(self):
         with pytest.raises(TypeError):
@@ -212,10 +199,9 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_cpu_rt_period(self):
         config = create_host_config(version='1.25', cpu_rt_period=1000)
-        self.assertEqual(config.get('CPURealtimePeriod'), 1000)
+        assert config.get('CPURealtimePeriod') == 1000
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.24', cpu_rt_period=1000)
-                version='1.24', cpu_rt_period=1000))
 
     def test_ctrate_host_config_with_cpu_rt_runtime_types(self):
         with pytest.raises(TypeError):
@@ -223,10 +209,9 @@ class HostConfigTest(unittest.TestCase):
 
     def test_create_host_config_with_cpu_rt_runtime(self):
         config = create_host_config(version='1.25', cpu_rt_runtime=1000)
-        self.assertEqual(config.get('CPURealtimeRuntime'), 1000)
+        assert config.get('CPURealtimeRuntime') == 1000
-        self.assertRaises(
+        with pytest.raises(InvalidVersion):
-            InvalidVersion, lambda: create_host_config(
+            create_host_config(version='1.24', cpu_rt_runtime=1000)
-                version='1.24', cpu_rt_runtime=1000))
 
 
 class ContainerConfigTest(unittest.TestCase):
@@ -264,43 +249,46 @@ class UlimitTest(unittest.TestCase):
         config = create_host_config(
             ulimits=[ulimit_dct], version=DEFAULT_DOCKER_API_VERSION
         )
-        self.assertIn('Ulimits', config)
+        assert 'Ulimits' in config
-        self.assertEqual(len(config['Ulimits']), 1)
+        assert len(config['Ulimits']) == 1
         ulimit_obj = config['Ulimits'][0]
-        self.assertTrue(isinstance(ulimit_obj, Ulimit))
+        assert isinstance(ulimit_obj, Ulimit)
-        self.assertEqual(ulimit_obj.name, ulimit_dct['name'])
+        assert ulimit_obj.name == ulimit_dct['name']
-        self.assertEqual(ulimit_obj.soft, ulimit_dct['soft'])
+        assert ulimit_obj.soft == ulimit_dct['soft']
-        self.assertEqual(ulimit_obj['Soft'], ulimit_obj.soft)
+        assert ulimit_obj['Soft'] == ulimit_obj.soft
 
     def test_create_host_config_dict_ulimit_capitals(self):
         ulimit_dct = {'Name': 'nofile', 'Soft': 8096, 'Hard': 8096 * 4}
         config = create_host_config(
             ulimits=[ulimit_dct], version=DEFAULT_DOCKER_API_VERSION
         )
-        self.assertIn('Ulimits', config)
+        assert 'Ulimits' in config
-        self.assertEqual(len(config['Ulimits']), 1)
+        assert len(config['Ulimits']) == 1
         ulimit_obj = config['Ulimits'][0]
-        self.assertTrue(isinstance(ulimit_obj, Ulimit))
+        assert isinstance(ulimit_obj, Ulimit)
-        self.assertEqual(ulimit_obj.name, ulimit_dct['Name'])
+        assert ulimit_obj.name == ulimit_dct['Name']
-        self.assertEqual(ulimit_obj.soft, ulimit_dct['Soft'])
+        assert ulimit_obj.soft == ulimit_dct['Soft']
-        self.assertEqual(ulimit_obj.hard, ulimit_dct['Hard'])
+        assert ulimit_obj.hard == ulimit_dct['Hard']
-        self.assertEqual(ulimit_obj['Soft'], ulimit_obj.soft)
+        assert ulimit_obj['Soft'] == ulimit_obj.soft
 
     def test_create_host_config_obj_ulimit(self):
         ulimit_dct = Ulimit(name='nofile', soft=8096)
         config = create_host_config(
             ulimits=[ulimit_dct], version=DEFAULT_DOCKER_API_VERSION
         )
-        self.assertIn('Ulimits', config)
+        assert 'Ulimits' in config
-        self.assertEqual(len(config['Ulimits']), 1)
+        assert len(config['Ulimits']) == 1
         ulimit_obj = config['Ulimits'][0]
-        self.assertTrue(isinstance(ulimit_obj, Ulimit))
+        assert isinstance(ulimit_obj, Ulimit)
-        self.assertEqual(ulimit_obj, ulimit_dct)
+        assert ulimit_obj == ulimit_dct
 
     def test_ulimit_invalid_type(self):
-        self.assertRaises(ValueError, lambda: Ulimit(name=None))
+        with pytest.raises(ValueError):
-        self.assertRaises(ValueError, lambda: Ulimit(name='hello', soft='123'))
+            Ulimit(name=None)
-        self.assertRaises(ValueError, lambda: Ulimit(name='hello', hard='456'))
+        with pytest.raises(ValueError):
+            Ulimit(name='hello', soft='123')
+        with pytest.raises(ValueError):
+            Ulimit(name='hello', hard='456')
 
 
 class LogConfigTest(unittest.TestCase):
@@ -309,18 +297,18 @@ class LogConfigTest(unittest.TestCase):
         config = create_host_config(
             version=DEFAULT_DOCKER_API_VERSION, log_config=dct
         )
-        self.assertIn('LogConfig', config)
+        assert 'LogConfig' in config
-        self.assertTrue(isinstance(config['LogConfig'], LogConfig))
+        assert isinstance(config['LogConfig'], LogConfig)
-        self.assertEqual(dct['type'], config['LogConfig'].type)
+        assert dct['type'] == config['LogConfig'].type
 
     def test_create_host_config_obj_logconfig(self):
         obj = LogConfig(type=LogConfig.types.SYSLOG, config={'key1': 'val1'})
         config = create_host_config(
             version=DEFAULT_DOCKER_API_VERSION, log_config=obj
         )
-        self.assertIn('LogConfig', config)
+        assert 'LogConfig' in config
-        self.assertTrue(isinstance(config['LogConfig'], LogConfig))
+        assert isinstance(config['LogConfig'], LogConfig)
-        self.assertEqual(obj, config['LogConfig'])
+        assert obj == config['LogConfig']
 
     def test_logconfig_invalid_config_type(self):
         with pytest.raises(ValueError):
@@ -342,7 +330,7 @@ class IPAMConfigTest(unittest.TestCase):
                              gateway='192.168.52.254')
 
         ipam_config = IPAMConfig(pool_configs=[ipam_pool])
-        self.assertEqual(ipam_config, {
+        assert ipam_config == {
             'Driver': 'default',
             'Config': [{
                 'Subnet': '192.168.52.0/24',
@@ -350,7 +338,7 @@ class IPAMConfigTest(unittest.TestCase):
                 'AuxiliaryAddresses': None,
                 'IPRange': None,
             }]
-        })
+        }
 
 
 class ServiceModeTest(unittest.TestCase):

tests/unit/models_containers_test.py

@@ -5,6 +5,7 @@ import unittest
 
 from .fake_api import FAKE_CONTAINER_ID, FAKE_IMAGE_ID, FAKE_EXEC_ID
 from .fake_api_client import make_fake_client
+import pytest
 
 
 class ContainerCollectionTest(unittest.TestCase):
@@ -232,10 +233,10 @@ class ContainerCollectionTest(unittest.TestCase):
         client.api.logs.return_value = "some error"
         client.api.wait.return_value = 1
 
-        with self.assertRaises(docker.errors.ContainerError) as cm:
+        with pytest.raises(docker.errors.ContainerError) as cm:
             client.containers.run('alpine', 'echo hello world')
-        assert cm.exception.exit_status == 1
+        assert cm.value.exit_status == 1
-        assert "some error" in str(cm.exception)
+        assert "some error" in cm.exconly()
 
     def test_run_with_image_object(self):
         client = make_fake_client()
@@ -257,7 +258,7 @@ class ContainerCollectionTest(unittest.TestCase):
 
         client = make_fake_client()
         client.api.wait.return_value = 1
-        with self.assertRaises(docker.errors.ContainerError):
+        with pytest.raises(docker.errors.ContainerError):
             client.containers.run("alpine")
         client.api.remove_container.assert_not_called()
 
@@ -267,18 +268,18 @@ class ContainerCollectionTest(unittest.TestCase):
 
         client = make_fake_client()
         client.api.wait.return_value = 1
-        with self.assertRaises(docker.errors.ContainerError):
+        with pytest.raises(docker.errors.ContainerError):
             client.containers.run("alpine", remove=True)
         client.api.remove_container.assert_called_with(FAKE_CONTAINER_ID)
 
         client = make_fake_client()
         client.api._version = '1.24'
-        with self.assertRaises(RuntimeError):
+        with pytest.raises(RuntimeError):
             client.containers.run("alpine", detach=True, remove=True)
 
         client = make_fake_client()
         client.api._version = '1.23'
-        with self.assertRaises(RuntimeError):
+        with pytest.raises(RuntimeError):
             client.containers.run("alpine", detach=True, remove=True)
 
         client = make_fake_client()

tests/unit/ssladapter_test.py

@@ -1,5 +1,6 @@
 import unittest
 from docker.transport import ssladapter
+import pytest
 
 try:
     from backports.ssl_match_hostname import (
@@ -69,11 +70,9 @@ class MatchHostnameTest(unittest.TestCase):
         assert match_hostname(self.cert, 'touhou.gensokyo.jp') is None
 
     def test_match_ip_address_failure(self):
-        self.assertRaises(
+        with pytest.raises(CertificateError):
-            CertificateError, match_hostname, self.cert, '192.168.0.25'
+            match_hostname(self.cert, '192.168.0.25')
-        )
 
     def test_match_dns_failure(self):
-        self.assertRaises(
+        with pytest.raises(CertificateError):
-            CertificateError, match_hostname, self.cert, 'foobar.co.uk'
+            match_hostname(self.cert, 'foobar.co.uk')
-        )

tests/unit/swarm_test.py

@@ -21,15 +21,11 @@ class SwarmTest(BaseAPIClientTest):
             node_id=fake_api.FAKE_NODE_ID, version=1, node_spec=node_spec
         )
         args = fake_request.call_args
-        self.assertEqual(
+        assert args[0][1] == (
-            args[0][1], url_prefix + 'nodes/24ifsmvkjbyhk/update?version=1'
+            url_prefix + 'nodes/24ifsmvkjbyhk/update?version=1'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']), node_spec
-        )
-        self.assertEqual(
-            args[1]['headers']['Content-Type'], 'application/json'
         )
+        assert json.loads(args[1]['data']) == node_spec
+        assert args[1]['headers']['Content-Type'] == 'application/json'
 
     @requires_api_version('1.24')
     def test_join_swarm(self):

tests/unit/utils_test.py

@@ -80,25 +80,25 @@ class KwargsFromEnvTest(unittest.TestCase):
         os.environ.pop('DOCKER_TLS_VERIFY', None)
 
         kwargs = kwargs_from_env()
-        self.assertEqual(None, kwargs.get('base_url'))
+        assert kwargs.get('base_url') is None
-        self.assertEqual(None, kwargs.get('tls'))
+        assert kwargs.get('tls') is None
 
     def test_kwargs_from_env_tls(self):
         os.environ.update(DOCKER_HOST='tcp://192.168.59.103:2376',
                           DOCKER_CERT_PATH=TEST_CERT_DIR,
                           DOCKER_TLS_VERIFY='1')
         kwargs = kwargs_from_env(assert_hostname=False)
-        self.assertEqual('https://192.168.59.103:2376', kwargs['base_url'])
+        assert 'https://192.168.59.103:2376' == kwargs['base_url']
-        self.assertTrue('ca.pem' in kwargs['tls'].ca_cert)
+        assert 'ca.pem' in kwargs['tls'].ca_cert
-        self.assertTrue('cert.pem' in kwargs['tls'].cert[0])
+        assert 'cert.pem' in kwargs['tls'].cert[0]
-        self.assertTrue('key.pem' in kwargs['tls'].cert[1])
+        assert 'key.pem' in kwargs['tls'].cert[1]
-        self.assertEqual(False, kwargs['tls'].assert_hostname)
+        assert kwargs['tls'].assert_hostname is False
-        self.assertTrue(kwargs['tls'].verify)
+        assert kwargs['tls'].verify
         try:
             client = APIClient(**kwargs)
-            self.assertEqual(kwargs['base_url'], client.base_url)
+            assert kwargs['base_url'] == client.base_url
-            self.assertEqual(kwargs['tls'].ca_cert, client.verify)
+            assert kwargs['tls'].ca_cert == client.verify
-            self.assertEqual(kwargs['tls'].cert, client.cert)
+            assert kwargs['tls'].cert == client.cert
         except TypeError as e:
             self.fail(e)
 
@@ -107,17 +107,17 @@ class KwargsFromEnvTest(unittest.TestCase):
                           DOCKER_CERT_PATH=TEST_CERT_DIR,
                           DOCKER_TLS_VERIFY='')
         kwargs = kwargs_from_env(assert_hostname=True)
-        self.assertEqual('https://192.168.59.103:2376', kwargs['base_url'])
+        assert 'https://192.168.59.103:2376' == kwargs['base_url']
-        self.assertTrue('ca.pem' in kwargs['tls'].ca_cert)
+        assert 'ca.pem' in kwargs['tls'].ca_cert
-        self.assertTrue('cert.pem' in kwargs['tls'].cert[0])
+        assert 'cert.pem' in kwargs['tls'].cert[0]
-        self.assertTrue('key.pem' in kwargs['tls'].cert[1])
+        assert 'key.pem' in kwargs['tls'].cert[1]
-        self.assertEqual(True, kwargs['tls'].assert_hostname)
+        assert kwargs['tls'].assert_hostname is True
-        self.assertEqual(False, kwargs['tls'].verify)
+        assert kwargs['tls'].verify is False
         try:
             client = APIClient(**kwargs)
-            self.assertEqual(kwargs['base_url'], client.base_url)
+            assert kwargs['base_url'] == client.base_url
-            self.assertEqual(kwargs['tls'].cert, client.cert)
+            assert kwargs['tls'].cert == client.cert
-            self.assertFalse(kwargs['tls'].verify)
+            assert not kwargs['tls'].verify
         except TypeError as e:
             self.fail(e)
 
@@ -131,7 +131,7 @@ class KwargsFromEnvTest(unittest.TestCase):
                           DOCKER_TLS_VERIFY='')
         os.environ.pop('DOCKER_CERT_PATH', None)
         kwargs = kwargs_from_env(assert_hostname=True)
-        self.assertEqual('tcp://192.168.59.103:2376', kwargs['base_url'])
+        assert 'tcp://192.168.59.103:2376' == kwargs['base_url']
 
     def test_kwargs_from_env_no_cert_path(self):
         try:
@@ -144,10 +144,10 @@ class KwargsFromEnvTest(unittest.TestCase):
                               DOCKER_TLS_VERIFY='1')
 
             kwargs = kwargs_from_env()
-            self.assertTrue(kwargs['tls'].verify)
+            assert kwargs['tls'].verify
-            self.assertIn(cert_dir, kwargs['tls'].ca_cert)
+            assert cert_dir in kwargs['tls'].ca_cert
-            self.assertIn(cert_dir, kwargs['tls'].cert[0])
+            assert cert_dir in kwargs['tls'].cert[0]
-            self.assertIn(cert_dir, kwargs['tls'].cert[1])
+            assert cert_dir in kwargs['tls'].cert[1]
         finally:
             if temp_dir:
                 shutil.rmtree(temp_dir)
@@ -169,12 +169,12 @@ class KwargsFromEnvTest(unittest.TestCase):
 
 class ConverVolumeBindsTest(unittest.TestCase):
     def test_convert_volume_binds_empty(self):
-        self.assertEqual(convert_volume_binds({}), [])
+        assert convert_volume_binds({}) == []
-        self.assertEqual(convert_volume_binds([]), [])
+        assert convert_volume_binds([]) == []
 
     def test_convert_volume_binds_list(self):
         data = ['/a:/a:ro', '/b:/c:z']
-        self.assertEqual(convert_volume_binds(data), data)
+        assert convert_volume_binds(data) == data
 
     def test_convert_volume_binds_complete(self):
         data = {
@@ -183,13 +183,13 @@ class ConverVolumeBindsTest(unittest.TestCase):
                 'mode': 'ro'
             }
         }
-        self.assertEqual(convert_volume_binds(data), ['/mnt/vol1:/data:ro'])
+        assert convert_volume_binds(data) == ['/mnt/vol1:/data:ro']
 
     def test_convert_volume_binds_compact(self):
         data = {
             '/mnt/vol1': '/data'
         }
-        self.assertEqual(convert_volume_binds(data), ['/mnt/vol1:/data:rw'])
+        assert convert_volume_binds(data) == ['/mnt/vol1:/data:rw']
 
     def test_convert_volume_binds_no_mode(self):
         data = {
@@ -197,7 +197,7 @@ class ConverVolumeBindsTest(unittest.TestCase):
                 'bind': '/data'
             }
         }
-        self.assertEqual(convert_volume_binds(data), ['/mnt/vol1:/data:rw'])
+        assert convert_volume_binds(data) == ['/mnt/vol1:/data:rw']
 
     def test_convert_volume_binds_unicode_bytes_input(self):
         expected = [u'/mnt/지연:/unicode/박:rw']
@@ -208,9 +208,7 @@ class ConverVolumeBindsTest(unittest.TestCase):
                 'mode': 'rw'
             }
         }
-        self.assertEqual(
+        assert convert_volume_binds(data) == expected
-            convert_volume_binds(data), expected
-        )
 
     def test_convert_volume_binds_unicode_unicode_input(self):
         expected = [u'/mnt/지연:/unicode/박:rw']
@@ -221,9 +219,7 @@ class ConverVolumeBindsTest(unittest.TestCase):
                 'mode': 'rw'
             }
         }
-        self.assertEqual(
+        assert convert_volume_binds(data) == expected
-            convert_volume_binds(data), expected
-        )
 
 
 class ParseEnvFileTest(unittest.TestCase):
@@ -242,38 +238,35 @@ class ParseEnvFileTest(unittest.TestCase):
         env_file = self.generate_tempfile(
             file_content='USER=jdoe\nPASS=secret')
         get_parse_env_file = parse_env_file(env_file)
-        self.assertEqual(get_parse_env_file,
+        assert get_parse_env_file == {'USER': 'jdoe', 'PASS': 'secret'}
-                         {'USER': 'jdoe', 'PASS': 'secret'})
         os.unlink(env_file)
 
     def test_parse_env_file_with_equals_character(self):
         env_file = self.generate_tempfile(
             file_content='USER=jdoe\nPASS=sec==ret')
         get_parse_env_file = parse_env_file(env_file)
-        self.assertEqual(get_parse_env_file,
+        assert get_parse_env_file == {'USER': 'jdoe', 'PASS': 'sec==ret'}
-                         {'USER': 'jdoe', 'PASS': 'sec==ret'})
         os.unlink(env_file)
 
     def test_parse_env_file_commented_line(self):
         env_file = self.generate_tempfile(
             file_content='USER=jdoe\n#PASS=secret')
         get_parse_env_file = parse_env_file(env_file)
-        self.assertEqual(get_parse_env_file, {'USER': 'jdoe'})
+        assert get_parse_env_file == {'USER': 'jdoe'}
         os.unlink(env_file)
 
     def test_parse_env_file_newline(self):
         env_file = self.generate_tempfile(
             file_content='\nUSER=jdoe\n\n\nPASS=secret')
         get_parse_env_file = parse_env_file(env_file)
-        self.assertEqual(get_parse_env_file,
+        assert get_parse_env_file == {'USER': 'jdoe', 'PASS': 'secret'}
-                         {'USER': 'jdoe', 'PASS': 'secret'})
         os.unlink(env_file)
 
     def test_parse_env_file_invalid_line(self):
         env_file = self.generate_tempfile(
             file_content='USER jdoe')
-        self.assertRaises(
+        with pytest.raises(DockerException):
-            DockerException, parse_env_file, env_file)
+            parse_env_file(env_file)
         os.unlink(env_file)
 
 
@@ -343,46 +336,34 @@ class ParseRepositoryTagTest(unittest.TestCase):
     sha = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
 
     def test_index_image_no_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("root") == ("root", None)
-            parse_repository_tag("root"), ("root", None)
-        )
 
     def test_index_image_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("root:tag") == ("root", "tag")
-            parse_repository_tag("root:tag"), ("root", "tag")
-        )
 
     def test_index_user_image_no_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("user/repo") == ("user/repo", None)
-            parse_repository_tag("user/repo"), ("user/repo", None)
-        )
 
     def test_index_user_image_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("user/repo:tag") == ("user/repo", "tag")
-            parse_repository_tag("user/repo:tag"), ("user/repo", "tag")
-        )
 
     def test_private_reg_image_no_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("url:5000/repo") == ("url:5000/repo", None)
-            parse_repository_tag("url:5000/repo"), ("url:5000/repo", None)
-        )
 
     def test_private_reg_image_tag(self):
-        self.assertEqual(
+        assert parse_repository_tag("url:5000/repo:tag") == (
-            parse_repository_tag("url:5000/repo:tag"), ("url:5000/repo", "tag")
+            "url:5000/repo", "tag"
         )
 
     def test_index_image_sha(self):
-        self.assertEqual(
+        assert parse_repository_tag("root@sha256:{0}".format(self.sha)) == (
-            parse_repository_tag("root@sha256:{0}".format(self.sha)),
+            "root", "sha256:{0}".format(self.sha)
-            ("root", "sha256:{0}".format(self.sha))
         )
 
     def test_private_reg_image_sha(self):
-        self.assertEqual(
+        assert parse_repository_tag(
-            parse_repository_tag("url:5000/repo@sha256:{0}".format(self.sha)),
+            "url:5000/repo@sha256:{0}".format(self.sha)
-            ("url:5000/repo", "sha256:{0}".format(self.sha))
+        ) == ("url:5000/repo", "sha256:{0}".format(self.sha))
-        )
 
 
 class ParseDeviceTest(unittest.TestCase):
@@ -392,35 +373,35 @@ class ParseDeviceTest(unittest.TestCase):
             'PathInContainer': '/dev/mnt1',
             'CgroupPermissions': 'r'
         }])
-        self.assertEqual(devices[0], {
+        assert devices[0] == {
             'PathOnHost': '/dev/sda1',
             'PathInContainer': '/dev/mnt1',
             'CgroupPermissions': 'r'
-        })
+        }
 
     def test_partial_string_definition(self):
         devices = parse_devices(['/dev/sda1'])
-        self.assertEqual(devices[0], {
+        assert devices[0] == {
             'PathOnHost': '/dev/sda1',
             'PathInContainer': '/dev/sda1',
             'CgroupPermissions': 'rwm'
-        })
+        }
 
     def test_permissionless_string_definition(self):
         devices = parse_devices(['/dev/sda1:/dev/mnt1'])
-        self.assertEqual(devices[0], {
+        assert devices[0] == {
             'PathOnHost': '/dev/sda1',
             'PathInContainer': '/dev/mnt1',
             'CgroupPermissions': 'rwm'
-        })
+        }
 
     def test_full_string_definition(self):
         devices = parse_devices(['/dev/sda1:/dev/mnt1:r'])
-        self.assertEqual(devices[0], {
+        assert devices[0] == {
             'PathOnHost': '/dev/sda1',
             'PathInContainer': '/dev/mnt1',
             'CgroupPermissions': 'r'
-        })
+        }
 
     def test_hybrid_list(self):
         devices = parse_devices([
@@ -432,36 +413,38 @@ class ParseDeviceTest(unittest.TestCase):
             }
         ])
 
-        self.assertEqual(devices[0], {
+        assert devices[0] == {
             'PathOnHost': '/dev/sda1',
             'PathInContainer': '/dev/mnt1',
             'CgroupPermissions': 'rw'
-        })
+        }
-        self.assertEqual(devices[1], {
+        assert devices[1] == {
             'PathOnHost': '/dev/sda2',
             'PathInContainer': '/dev/mnt2',
             'CgroupPermissions': 'r'
-        })
+        }
 
 
 class ParseBytesTest(unittest.TestCase):
     def test_parse_bytes_valid(self):
-        self.assertEqual(parse_bytes("512MB"), 536870912)
+        assert parse_bytes("512MB") == 536870912
-        self.assertEqual(parse_bytes("512M"), 536870912)
+        assert parse_bytes("512M") == 536870912
-        self.assertEqual(parse_bytes("512m"), 536870912)
+        assert parse_bytes("512m") == 536870912
 
     def test_parse_bytes_invalid(self):
-        self.assertRaises(DockerException, parse_bytes, "512MK")
+        with pytest.raises(DockerException):
-        self.assertRaises(DockerException, parse_bytes, "512L")
+            parse_bytes("512MK")
-        self.assertRaises(DockerException, parse_bytes, "127.0.0.1K")
+        with pytest.raises(DockerException):
+            parse_bytes("512L")
+        with pytest.raises(DockerException):
+            parse_bytes("127.0.0.1K")
 
     def test_parse_bytes_float(self):
-        self.assertRaises(DockerException, parse_bytes, "1.5k")
+        with pytest.raises(DockerException):
+            parse_bytes("1.5k")
 
     def test_parse_bytes_maxint(self):
-        self.assertEqual(
+        assert parse_bytes("{0}k".format(sys.maxsize)) == sys.maxsize * 1024
-            parse_bytes("{0}k".format(sys.maxsize)), sys.maxsize * 1024
-        )
 
 
 class UtilsTest(unittest.TestCase):
@@ -476,7 +459,7 @@ class UtilsTest(unittest.TestCase):
         ]
 
         for filters, expected in tests:
-            self.assertEqual(convert_filters(filters), expected)
+            assert convert_filters(filters) == expected
 
     def test_decode_json_header(self):
         obj = {'a': 'b', 'c': 1}
@@ -486,144 +469,144 @@ class UtilsTest(unittest.TestCase):
         else:
             data = base64.urlsafe_b64encode(json.dumps(obj))
         decoded_data = decode_json_header(data)
-        self.assertEqual(obj, decoded_data)
+        assert obj == decoded_data
 
 
 class SplitCommandTest(unittest.TestCase):
     def test_split_command_with_unicode(self):
-        self.assertEqual(split_command(u'echo μμ'), ['echo', 'μμ'])
+        assert split_command(u'echo μμ') == ['echo', 'μμ']
 
     @pytest.mark.skipif(six.PY3, reason="shlex doesn't support bytes in py3")
     def test_split_command_with_bytes(self):
-        self.assertEqual(split_command('echo μμ'), ['echo', 'μμ'])
+        assert split_command('echo μμ') == ['echo', 'μμ']
 
 
 class PortsTest(unittest.TestCase):
     def test_split_port_with_host_ip(self):
         internal_port, external_port = split_port("127.0.0.1:1000:2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, [("127.0.0.1", "1000")])
+        assert external_port == [("127.0.0.1", "1000")]
 
     def test_split_port_with_protocol(self):
         internal_port, external_port = split_port("127.0.0.1:1000:2000/udp")
-        self.assertEqual(internal_port, ["2000/udp"])
+        assert internal_port == ["2000/udp"]
-        self.assertEqual(external_port, [("127.0.0.1", "1000")])
+        assert external_port == [("127.0.0.1", "1000")]
 
     def test_split_port_with_host_ip_no_port(self):
         internal_port, external_port = split_port("127.0.0.1::2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, [("127.0.0.1", None)])
+        assert external_port == [("127.0.0.1", None)]
 
     def test_split_port_range_with_host_ip_no_port(self):
         internal_port, external_port = split_port("127.0.0.1::2000-2001")
-        self.assertEqual(internal_port, ["2000", "2001"])
+        assert internal_port == ["2000", "2001"]
-        self.assertEqual(external_port,
+        assert external_port == [("127.0.0.1", None), ("127.0.0.1", None)]
-                         [("127.0.0.1", None), ("127.0.0.1", None)])
 
     def test_split_port_with_host_port(self):
         internal_port, external_port = split_port("1000:2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, ["1000"])
+        assert external_port == ["1000"]
 
     def test_split_port_range_with_host_port(self):
         internal_port, external_port = split_port("1000-1001:2000-2001")
-        self.assertEqual(internal_port, ["2000", "2001"])
+        assert internal_port == ["2000", "2001"]
-        self.assertEqual(external_port, ["1000", "1001"])
+        assert external_port == ["1000", "1001"]
 
     def test_split_port_random_port_range_with_host_port(self):
         internal_port, external_port = split_port("1000-1001:2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, ["1000-1001"])
+        assert external_port == ["1000-1001"]
 
     def test_split_port_no_host_port(self):
         internal_port, external_port = split_port("2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, None)
+        assert external_port is None
 
     def test_split_port_range_no_host_port(self):
         internal_port, external_port = split_port("2000-2001")
-        self.assertEqual(internal_port, ["2000", "2001"])
+        assert internal_port == ["2000", "2001"]
-        self.assertEqual(external_port, None)
+        assert external_port is None
 
     def test_split_port_range_with_protocol(self):
         internal_port, external_port = split_port(
             "127.0.0.1:1000-1001:2000-2001/udp")
-        self.assertEqual(internal_port, ["2000/udp", "2001/udp"])
+        assert internal_port == ["2000/udp", "2001/udp"]
-        self.assertEqual(external_port,
+        assert external_port == [("127.0.0.1", "1000"), ("127.0.0.1", "1001")]
-                         [("127.0.0.1", "1000"), ("127.0.0.1", "1001")])
 
     def test_split_port_with_ipv6_address(self):
         internal_port, external_port = split_port(
             "2001:abcd:ef00::2:1000:2000")
-        self.assertEqual(internal_port, ["2000"])
+        assert internal_port == ["2000"]
-        self.assertEqual(external_port, [("2001:abcd:ef00::2", "1000")])
+        assert external_port == [("2001:abcd:ef00::2", "1000")]
 
     def test_split_port_invalid(self):
-        self.assertRaises(ValueError,
+        with pytest.raises(ValueError):
-                          lambda: split_port("0.0.0.0:1000:2000:tcp"))
+            split_port("0.0.0.0:1000:2000:tcp")
 
     def test_non_matching_length_port_ranges(self):
-        self.assertRaises(
+        with pytest.raises(ValueError):
-            ValueError,
+            split_port("0.0.0.0:1000-1010:2000-2002/tcp")
-            lambda: split_port("0.0.0.0:1000-1010:2000-2002/tcp")
-        )
 
     def test_port_and_range_invalid(self):
-        self.assertRaises(ValueError,
+        with pytest.raises(ValueError):
-                          lambda: split_port("0.0.0.0:1000:2000-2002/tcp"))
+            split_port("0.0.0.0:1000:2000-2002/tcp")
 
     def test_port_only_with_colon(self):
-        self.assertRaises(ValueError,
+        with pytest.raises(ValueError):
-                          lambda: split_port(":80"))
+            split_port(":80")
 
     def test_host_only_with_colon(self):
-        self.assertRaises(ValueError,
+        with pytest.raises(ValueError):
-                          lambda: split_port("localhost:"))
+            split_port("localhost:")
 
     def test_with_no_container_port(self):
-        self.assertRaises(ValueError,
+        with pytest.raises(ValueError):
-                          lambda: split_port("localhost:80:"))
+            split_port("localhost:80:")
 
     def test_split_port_empty_string(self):
-        self.assertRaises(ValueError, lambda: split_port(""))
+        with pytest.raises(ValueError):
+            split_port("")
 
     def test_split_port_non_string(self):
         assert split_port(1243) == (['1243'], None)
 
     def test_build_port_bindings_with_one_port(self):
         port_bindings = build_port_bindings(["127.0.0.1:1000:1000"])
-        self.assertEqual(port_bindings["1000"], [("127.0.0.1", "1000")])
+        assert port_bindings["1000"] == [("127.0.0.1", "1000")]
 
     def test_build_port_bindings_with_matching_internal_ports(self):
         port_bindings = build_port_bindings(
             ["127.0.0.1:1000:1000", "127.0.0.1:2000:1000"])
-        self.assertEqual(port_bindings["1000"],
+        assert port_bindings["1000"] == [
-                         [("127.0.0.1", "1000"), ("127.0.0.1", "2000")])
+            ("127.0.0.1", "1000"), ("127.0.0.1", "2000")
+        ]
 
     def test_build_port_bindings_with_nonmatching_internal_ports(self):
         port_bindings = build_port_bindings(
             ["127.0.0.1:1000:1000", "127.0.0.1:2000:2000"])
-        self.assertEqual(port_bindings["1000"], [("127.0.0.1", "1000")])
+        assert port_bindings["1000"] == [("127.0.0.1", "1000")]
-        self.assertEqual(port_bindings["2000"], [("127.0.0.1", "2000")])
+        assert port_bindings["2000"] == [("127.0.0.1", "2000")]
 
     def test_build_port_bindings_with_port_range(self):
         port_bindings = build_port_bindings(["127.0.0.1:1000-1001:1000-1001"])
-        self.assertEqual(port_bindings["1000"], [("127.0.0.1", "1000")])
+        assert port_bindings["1000"] == [("127.0.0.1", "1000")]
-        self.assertEqual(port_bindings["1001"], [("127.0.0.1", "1001")])
+        assert port_bindings["1001"] == [("127.0.0.1", "1001")]
 
     def test_build_port_bindings_with_matching_internal_port_ranges(self):
         port_bindings = build_port_bindings(
             ["127.0.0.1:1000-1001:1000-1001", "127.0.0.1:2000-2001:1000-1001"])
-        self.assertEqual(port_bindings["1000"],
+        assert port_bindings["1000"] == [
-                         [("127.0.0.1", "1000"), ("127.0.0.1", "2000")])
+            ("127.0.0.1", "1000"), ("127.0.0.1", "2000")
-        self.assertEqual(port_bindings["1001"],
+        ]
-                         [("127.0.0.1", "1001"), ("127.0.0.1", "2001")])
+        assert port_bindings["1001"] == [
+            ("127.0.0.1", "1001"), ("127.0.0.1", "2001")
+        ]
 
     def test_build_port_bindings_with_nonmatching_internal_port_ranges(self):
         port_bindings = build_port_bindings(
             ["127.0.0.1:1000:1000", "127.0.0.1:2000:2000"])
-        self.assertEqual(port_bindings["1000"], [("127.0.0.1", "1000")])
+        assert port_bindings["1000"] == [("127.0.0.1", "1000")]
-        self.assertEqual(port_bindings["2000"], [("127.0.0.1", "2000")])
+        assert port_bindings["2000"] == [("127.0.0.1", "2000")]
 
 
 def convert_paths(collection):
@@ -708,11 +691,13 @@ class ExcludePathsTest(unittest.TestCase):
         If we're using a custom Dockerfile, make sure that's not
         excluded.
         """
-        assert self.exclude(['*'], dockerfile='Dockerfile.alt') == \
+        assert self.exclude(['*'], dockerfile='Dockerfile.alt') == set(
-            set(['Dockerfile.alt', '.dockerignore'])
+            ['Dockerfile.alt', '.dockerignore']
+        )
 
-        assert self.exclude(['*'], dockerfile='foo/Dockerfile3') == \
+        assert self.exclude(
-            convert_paths(set(['foo/Dockerfile3', '.dockerignore']))
+            ['*'], dockerfile='foo/Dockerfile3'
+        ) == convert_paths(set(['foo/Dockerfile3', '.dockerignore']))
 
     def test_exclude_dockerfile_child(self):
         includes = self.exclude(['foo/'], dockerfile='foo/Dockerfile3')
@@ -946,7 +931,7 @@ class TarTest(unittest.TestCase):
             os.makedirs(os.path.join(base, d))
         with tar(base) as archive:
             tar_data = tarfile.open(fileobj=archive)
-            self.assertEqual(sorted(tar_data.getnames()), ['bar', 'foo'])
+            assert sorted(tar_data.getnames()) == ['bar', 'foo']
 
     @pytest.mark.skipif(IS_WINDOWS_PLATFORM, reason='No chmod on Windows')
     def test_tar_with_inaccessible_file(self):
@@ -972,9 +957,7 @@ class TarTest(unittest.TestCase):
         os.symlink('../foo', os.path.join(base, 'bar/foo'))
         with tar(base) as archive:
             tar_data = tarfile.open(fileobj=archive)
-            self.assertEqual(
+            assert sorted(tar_data.getnames()) == ['bar', 'bar/foo', 'foo']
-                sorted(tar_data.getnames()), ['bar', 'bar/foo', 'foo']
-            )
 
     @pytest.mark.skipif(IS_WINDOWS_PLATFORM, reason='No symlinks on Windows')
     def test_tar_with_directory_symlinks(self):
@@ -985,9 +968,7 @@ class TarTest(unittest.TestCase):
         os.symlink('../foo', os.path.join(base, 'bar/foo'))
         with tar(base) as archive:
             tar_data = tarfile.open(fileobj=archive)
-            self.assertEqual(
+            assert sorted(tar_data.getnames()) == ['bar', 'bar/foo', 'foo']
-                sorted(tar_data.getnames()), ['bar', 'bar/foo', 'foo']
-            )
 
     @pytest.mark.skipif(IS_WINDOWS_PLATFORM, reason='No symlinks on Windows')
     def test_tar_with_broken_symlinks(self):
@@ -1012,9 +993,7 @@ class TarTest(unittest.TestCase):
         sock.bind(os.path.join(base, 'test.sock'))
         with tar(base) as archive:
             tar_data = tarfile.open(fileobj=archive)
-            self.assertEqual(
+            assert sorted(tar_data.getnames()) == ['bar', 'foo']
-                sorted(tar_data.getnames()), ['bar', 'foo']
-            )
 
 
 class ShouldCheckDirectoryTest(unittest.TestCase):