Use pytest asserts

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

tests/integration/api_build_test.py

@@ -43,7 +43,7 @@ class BuildTest(BaseAPIIntegrationTest):
             if six.PY3:
                 chunk = chunk.decode('utf-8')
             logs += chunk
-        self.assertNotEqual(logs, '')
+        assert logs != ''
 
     @requires_api_version('1.8')
     def test_build_with_dockerignore(self):
@@ -92,11 +92,10 @@ class BuildTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
 
-        self.assertEqual(
-            sorted(list(filter(None, logs.split('\n')))),
-            sorted(['/test/ignored/subdir/excepted-file',
-                    '/test/not-ignored']),
-        )
+        assert sorted(list(filter(None, logs.split('\n')))) == sorted([
+            '/test/ignored/subdir/excepted-file',
+            '/test/not-ignored'
+        ])
 
     @requires_api_version('1.21')
     def test_build_with_buildargs(self):
@@ -114,7 +113,7 @@ class BuildTest(BaseAPIIntegrationTest):
             pass
 
         info = self.client.inspect_image('buildargs')
-        self.assertEqual(info['Config']['User'], 'OK')
+        assert info['Config']['User'] == 'OK'
 
     @requires_api_version('1.22')
     def test_build_shmsize(self):
@@ -152,7 +151,7 @@ class BuildTest(BaseAPIIntegrationTest):
             pass
 
         info = self.client.inspect_image('labels')
-        self.assertEqual(info['Config']['Labels'], labels)
+        assert info['Config']['Labels'] == labels
 
     @requires_api_version('1.25')
     def test_build_with_cache_from(self):
@@ -309,8 +308,8 @@ class BuildTest(BaseAPIIntegrationTest):
 
         non_squashed = build_squashed(False)
         squashed = build_squashed(True)
-        self.assertEqual(len(non_squashed['RootFS']['Layers']), 4)
-        self.assertEqual(len(squashed['RootFS']['Layers']), 2)
+        assert len(non_squashed['RootFS']['Layers']) == 4
+        assert len(squashed['RootFS']['Layers']) == 2
 
     def test_build_stderr_data(self):
         control_chars = ['\x1b[91m', '\x1b[0m']
@@ -329,7 +328,7 @@ class BuildTest(BaseAPIIntegrationTest):
         expected = '{0}{2}\n{1}'.format(
             control_chars[0], control_chars[1], snippet
         )
-        self.assertTrue(any([line == expected for line in lines]))
+        assert any([line == expected for line in lines])
 
     def test_build_gzip_encoding(self):
         base_dir = tempfile.mkdtemp()
@@ -375,7 +374,7 @@ class BuildTest(BaseAPIIntegrationTest):
         assert 'Successfully built' in lines[-1]['stream']
 
     def test_build_gzip_custom_encoding(self):
-        with self.assertRaises(errors.DockerException):
+        with pytest.raises(errors.DockerException):
             self.client.build(path='.', gzip=True, encoding='text/html')
 
     @requires_api_version('1.32')

tests/integration/api_client_test.py

@@ -14,14 +14,14 @@ from .base import BaseAPIIntegrationTest
 class InformationTest(BaseAPIIntegrationTest):
     def test_version(self):
         res = self.client.version()
-        self.assertIn('GoVersion', res)
-        self.assertIn('Version', res)
+        assert 'GoVersion' in res
+        assert 'Version' in res
 
     def test_info(self):
         res = self.client.info()
-        self.assertIn('Containers', res)
-        self.assertIn('Images', res)
-        self.assertIn('Debug', res)
+        assert 'Containers' in res
+        assert 'Images' in res
+        assert 'Debug' in res
 
 
 class LoadConfigTest(BaseAPIIntegrationTest):
@@ -35,12 +35,12 @@ class LoadConfigTest(BaseAPIIntegrationTest):
         f.write('email = sakuya@scarlet.net')
         f.close()
         cfg = docker.auth.load_config(cfg_path)
-        self.assertNotEqual(cfg[docker.auth.INDEX_NAME], None)
+        assert cfg[docker.auth.INDEX_NAME] is not None
         cfg = cfg[docker.auth.INDEX_NAME]
-        self.assertEqual(cfg['username'], 'sakuya')
-        self.assertEqual(cfg['password'], 'izayoi')
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
-        self.assertEqual(cfg.get('Auth'), None)
+        assert cfg['username'] == 'sakuya'
+        assert cfg['password'] == 'izayoi'
+        assert cfg['email'] == 'sakuya@scarlet.net'
+        assert cfg.get('Auth') is None
 
     def test_load_json_config(self):
         folder = tempfile.mkdtemp()
@@ -53,12 +53,12 @@ class LoadConfigTest(BaseAPIIntegrationTest):
             docker.auth.INDEX_URL, auth_, email_))
         f.close()
         cfg = docker.auth.load_config(cfg_path)
-        self.assertNotEqual(cfg[docker.auth.INDEX_URL], None)
+        assert cfg[docker.auth.INDEX_URL] is not None
         cfg = cfg[docker.auth.INDEX_URL]
-        self.assertEqual(cfg['username'], 'sakuya')
-        self.assertEqual(cfg['password'], 'izayoi')
-        self.assertEqual(cfg['email'], 'sakuya@scarlet.net')
-        self.assertEqual(cfg.get('Auth'), None)
+        assert cfg['username'] == 'sakuya'
+        assert cfg['password'] == 'izayoi'
+        assert cfg['email'] == 'sakuya@scarlet.net'
+        assert cfg.get('Auth') is None
 
 
 class AutoDetectVersionTest(unittest.TestCase):
@@ -66,9 +66,9 @@ class AutoDetectVersionTest(unittest.TestCase):
         client = docker.APIClient(version='auto', **kwargs_from_env())
         client_version = client._version
         api_version = client.version(api_version=False)['ApiVersion']
-        self.assertEqual(client_version, api_version)
+        assert client_version == api_version
         api_version_2 = client.version()['ApiVersion']
-        self.assertEqual(client_version, api_version_2)
+        assert client_version == api_version_2
         client.close()
 
 
@@ -90,8 +90,8 @@ class ConnectionTimeoutTest(unittest.TestCase):
         except:
             pass
         end = time.time()
-        self.assertTrue(res is None)
-        self.assertTrue(end - start < 2 * self.timeout)
+        assert res is None
+        assert end - start < 2 * self.timeout
 
 
 class UnixconnTest(unittest.TestCase):
@@ -112,5 +112,6 @@ class UnixconnTest(unittest.TestCase):
             client.close()
             del client
 
-            assert len(w) == 0, \
-                "No warnings produced: {0}".format(w[0].message)
+            assert len(w) == 0, "No warnings produced: {0}".format(
+                w[0].message
+            )

tests/integration/api_exec_test.py

@@ -14,10 +14,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, ['echo', 'hello'])
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'hello\n')
+        assert exec_log == b'hello\n'
 
     def test_exec_command_string(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -27,10 +27,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'echo hello world')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'hello world\n')
+        assert exec_log == b'hello world\n'
 
     def test_exec_command_as_user(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -40,10 +40,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'whoami', user='default')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'default\n')
+        assert exec_log == b'default\n'
 
     def test_exec_command_as_root(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -53,10 +53,10 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         res = self.client.exec_create(id, 'whoami')
-        self.assertIn('Id', res)
+        assert 'Id' in res
 
         exec_log = self.client.exec_start(res)
-        self.assertEqual(exec_log, b'root\n')
+        assert exec_log == b'root\n'
 
     def test_exec_command_streaming(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -66,12 +66,12 @@ class ExecTest(BaseAPIIntegrationTest):
         self.client.start(id)
 
         exec_id = self.client.exec_create(id, ['echo', 'hello\nworld'])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         res = b''
         for chunk in self.client.exec_start(exec_id, stream=True):
             res += chunk
-        self.assertEqual(res, b'hello\nworld\n')
+        assert res == b'hello\nworld\n'
 
     def test_exec_start_socket(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -84,15 +84,15 @@ class ExecTest(BaseAPIIntegrationTest):
         # `echo` appends CRLF, `printf` doesn't
         exec_id = self.client.exec_create(
             container_id, ['printf', line], tty=True)
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         socket = self.client.exec_start(exec_id, socket=True)
         self.addCleanup(socket.close)
 
         next_size = next_frame_size(socket)
-        self.assertEqual(next_size, len(line))
+        assert next_size == len(line)
         data = read_exactly(socket, next_size)
-        self.assertEqual(data.decode('utf-8'), line)
+        assert data.decode('utf-8') == line
 
     def test_exec_start_detached(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -103,11 +103,11 @@ class ExecTest(BaseAPIIntegrationTest):
 
         exec_id = self.client.exec_create(
             container_id, ['printf', "asdqwe"])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
 
         response = self.client.exec_start(exec_id, detach=True)
 
-        self.assertEqual(response, "")
+        assert response == ""
 
     def test_exec_inspect(self):
         container = self.client.create_container(BUSYBOX, 'cat',
@@ -117,11 +117,11 @@ class ExecTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
 
         exec_id = self.client.exec_create(id, ['mkdir', '/does/not/exist'])
-        self.assertIn('Id', exec_id)
+        assert 'Id' in exec_id
         self.client.exec_start(exec_id)
         exec_info = self.client.exec_inspect(exec_id)
-        self.assertIn('ExitCode', exec_info)
-        self.assertNotEqual(exec_info['ExitCode'], 0)
+        assert 'ExitCode' in exec_info
+        assert exec_info['ExitCode'] != 0
 
     @requires_api_version('1.25')
     def test_exec_command_with_env(self):

tests/integration/api_healthcheck_test.py

@@ -20,8 +20,9 @@ class HealthcheckTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
 
         res = self.client.inspect_container(container)
-        assert res['Config']['Healthcheck']['Test'] == \
-            ['CMD-SHELL', 'echo "hello world"']
+        assert res['Config']['Healthcheck']['Test'] == [
+            'CMD-SHELL', 'echo "hello world"'
+        ]
 
     @helpers.requires_api_version('1.24')
     def test_healthcheck_passes(self):

tests/integration/api_image_test.py

@@ -21,19 +21,19 @@ from .base import BaseAPIIntegrationTest, BUSYBOX
 class ListImagesTest(BaseAPIIntegrationTest):
     def test_images(self):
         res1 = self.client.images(all=True)
-        self.assertIn('Id', res1[0])
+        assert 'Id' in res1[0]
         res10 = res1[0]
-        self.assertIn('Created', res10)
-        self.assertIn('RepoTags', res10)
+        assert 'Created' in res10
+        assert 'RepoTags' in res10
         distinct = []
         for img in res1:
             if img['Id'] not in distinct:
                 distinct.append(img['Id'])
-        self.assertEqual(len(distinct), self.client.info()['Images'])
+        assert len(distinct) == self.client.info()['Images']
 
     def test_images_quiet(self):
         res1 = self.client.images(quiet=True)
-        self.assertEqual(type(res1[0]), six.text_type)
+        assert type(res1[0]) == six.text_type
 
 
 class PullImageTest(BaseAPIIntegrationTest):
@@ -44,12 +44,10 @@ class PullImageTest(BaseAPIIntegrationTest):
             pass
         res = self.client.pull('hello-world', tag='latest')
         self.tmp_imgs.append('hello-world')
-        self.assertEqual(type(res), six.text_type)
-        self.assertGreaterEqual(
-            len(self.client.images('hello-world')), 1
-        )
+        assert type(res) == six.text_type
+        assert len(self.client.images('hello-world')) >= 1
         img_info = self.client.inspect_image('hello-world')
-        self.assertIn('Id', img_info)
+        assert 'Id' in img_info
 
     def test_pull_streaming(self):
         try:
@@ -61,11 +59,9 @@ class PullImageTest(BaseAPIIntegrationTest):
         self.tmp_imgs.append('hello-world')
         for chunk in stream:
             assert isinstance(chunk, dict)
-        self.assertGreaterEqual(
-            len(self.client.images('hello-world')), 1
-        )
+        assert len(self.client.images('hello-world')) >= 1
         img_info = self.client.inspect_image('hello-world')
-        self.assertIn('Id', img_info)
+        assert 'Id' in img_info
 
     @requires_api_version('1.32')
     @requires_experimental(until=None)
@@ -84,18 +80,18 @@ class CommitTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         res = self.client.commit(id)
-        self.assertIn('Id', res)
+        assert 'Id' in res
         img_id = res['Id']
         self.tmp_imgs.append(img_id)
         img = self.client.inspect_image(img_id)
-        self.assertIn('Container', img)
-        self.assertTrue(img['Container'].startswith(id))
-        self.assertIn('ContainerConfig', img)
-        self.assertIn('Image', img['ContainerConfig'])
-        self.assertEqual(BUSYBOX, img['ContainerConfig']['Image'])
+        assert 'Container' in img
+        assert img['Container'].startswith(id)
+        assert 'ContainerConfig' in img
+        assert 'Image' in img['ContainerConfig']
+        assert BUSYBOX == img['ContainerConfig']['Image']
         busybox_id = self.client.inspect_image(BUSYBOX)['Id']
-        self.assertIn('Parent', img)
-        self.assertEqual(img['Parent'], busybox_id)
+        assert 'Parent' in img
+        assert img['Parent'] == busybox_id
 
     def test_commit_with_changes(self):
         cid = self.client.create_container(BUSYBOX, ['touch', '/test'])
@@ -119,14 +115,14 @@ class RemoveImageTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         res = self.client.commit(id)
-        self.assertIn('Id', res)
+        assert 'Id' in res
         img_id = res['Id']
         self.tmp_imgs.append(img_id)
         logs = self.client.remove_image(img_id, force=True)
-        self.assertIn({"Deleted": img_id}, logs)
+        assert {"Deleted": img_id} in logs
         images = self.client.images(all=True)
         res = [x for x in images if x['Id'].startswith(img_id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
 
 class ImportImageTest(BaseAPIIntegrationTest):
@@ -180,7 +176,7 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
         img_id = result['status']
         self.tmp_imgs.append(img_id)
@@ -195,9 +191,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 
@@ -210,9 +206,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 
@@ -305,9 +301,9 @@ class ImportImageTest(BaseAPIIntegrationTest):
         result_text = statuses.splitlines()[-1]
         result = json.loads(result_text)
 
-        self.assertNotIn('error', result)
+        assert 'error' not in result
 
-        self.assertIn('status', result)
+        assert 'status' in result
         img_id = result['status']
         self.tmp_imgs.append(img_id)
 

tests/integration/api_network_test.py

@@ -24,24 +24,24 @@ class TestNetworks(BaseAPIIntegrationTest):
         net_name, net_id = self.create_network()
 
         networks = self.client.networks()
-        self.assertTrue(net_id in [n['Id'] for n in networks])
+        assert net_id in [n['Id'] for n in networks]
 
         networks_by_name = self.client.networks(names=[net_name])
-        self.assertEqual([n['Id'] for n in networks_by_name], [net_id])
+        assert [n['Id'] for n in networks_by_name] == [net_id]
 
         networks_by_partial_id = self.client.networks(ids=[net_id[:8]])
-        self.assertEqual([n['Id'] for n in networks_by_partial_id], [net_id])
+        assert [n['Id'] for n in networks_by_partial_id] == [net_id]
 
     @requires_api_version('1.21')
     def test_inspect_network(self):
         net_name, net_id = self.create_network()
 
         net = self.client.inspect_network(net_id)
-        self.assertEqual(net['Id'], net_id)
-        self.assertEqual(net['Name'], net_name)
-        self.assertEqual(net['Driver'], 'bridge')
-        self.assertEqual(net['Scope'], 'local')
-        self.assertEqual(net['IPAM']['Driver'], 'default')
+        assert net['Id'] == net_id
+        assert net['Name'] == net_name
+        assert net['Driver'] == 'bridge'
+        assert net['Scope'] == 'local'
+        assert net['IPAM']['Driver'] == 'default'
 
     @requires_api_version('1.21')
     def test_create_network_with_ipam_config(self):
@@ -103,21 +103,20 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         self.client.connect_container_to_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
-            [container['Id']]
-        )
+        assert list(network_data['Containers'].keys()) == [
+            container['Id']
+        ]
 
         with pytest.raises(docker.errors.APIError):
             self.client.connect_container_to_network(container, net_id)
 
         self.client.disconnect_container_from_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         with pytest.raises(docker.errors.APIError):
             self.client.disconnect_container_from_network(container, net_id)
@@ -131,18 +130,16 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         self.client.connect_container_to_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
+        assert list(network_data['Containers'].keys()) == \
             [container['Id']]
-        )
 
         self.client.disconnect_container_from_network(container, net_id, True)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
         with pytest.raises(docker.errors.APIError):
             self.client.disconnect_container_from_network(
@@ -179,13 +176,12 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.client.start(container)
 
         network_data = self.client.inspect_network(net_id)
-        self.assertEqual(
-            list(network_data['Containers'].keys()),
-            [container['Id']])
+        assert list(network_data['Containers'].keys()) == \
+            [container['Id']]
 
         self.client.disconnect_container_from_network(container, net_id)
         network_data = self.client.inspect_network(net_id)
-        self.assertFalse(network_data.get('Containers'))
+        assert not network_data.get('Containers')
 
     @requires_api_version('1.22')
     def test_create_with_aliases(self):
@@ -233,14 +229,11 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data[
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
-                'IPv4Address'
-            ],
-            '132.124.0.23'
-        )
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv4Address']\
+            == '132.124.0.23'
 
     @requires_api_version('1.22')
     def test_create_with_ipv6_address(self):
@@ -262,14 +255,11 @@ class TestNetworks(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data[
-                'NetworkSettings']['Networks'][net_name]['IPAMConfig'][
-                'IPv6Address'
-            ],
-            '2001:389::f00d'
-        )
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['IPAMConfig']['IPv6Address']\
+            == '2001:389::f00d'
 
     @requires_api_version('1.24')
     def test_create_with_linklocal_ips(self):
@@ -305,10 +295,12 @@ class TestNetworks(BaseAPIIntegrationTest):
             }),
         )
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
-            ['docker-py-test-upstream:bar'])
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['Links'] == [
+            'docker-py-test-upstream:bar'
+        ]
 
         self.create_and_start(
             name='docker-py-test-upstream',
@@ -320,7 +312,7 @@ class TestNetworks(BaseAPIIntegrationTest):
     @requires_api_version('1.21')
     def test_create_check_duplicate(self):
         net_name, net_id = self.create_network()
-        with self.assertRaises(docker.errors.APIError):
+        with pytest.raises(docker.errors.APIError):
             self.client.create_network(net_name, check_duplicate=True)
         net_id = self.client.create_network(net_name, check_duplicate=False)
         self.tmp_networks.append(net_id['Id'])
@@ -337,10 +329,12 @@ class TestNetworks(BaseAPIIntegrationTest):
             container, net_name,
             links=[('docker-py-test-upstream', 'bar')])
 
-        container_data = self.client.inspect_container(container)
-        self.assertEqual(
-            container_data['NetworkSettings']['Networks'][net_name]['Links'],
-            ['docker-py-test-upstream:bar'])
+        net_settings = self.client.inspect_container(container)[
+            'NetworkSettings'
+        ]
+        assert net_settings['Networks'][net_name]['Links'] == [
+            'docker-py-test-upstream:bar'
+        ]
 
         self.create_and_start(
             name='docker-py-test-upstream',
@@ -373,9 +367,7 @@ class TestNetworks(BaseAPIIntegrationTest):
 
         container_data = self.client.inspect_container(container)
         net_data = container_data['NetworkSettings']['Networks'][net_name]
-        self.assertEqual(
-            net_data['IPAMConfig']['IPv4Address'], '172.28.5.24'
-        )
+        assert net_data['IPAMConfig']['IPv4Address'] == '172.28.5.24'
 
     @requires_api_version('1.22')
     def test_connect_with_ipv6_address(self):
@@ -401,9 +393,7 @@ class TestNetworks(BaseAPIIntegrationTest):
 
         container_data = self.client.inspect_container(container)
         net_data = container_data['NetworkSettings']['Networks'][net_name]
-        self.assertEqual(
-            net_data['IPAMConfig']['IPv6Address'], '2001:389::f00d'
-        )
+        assert net_data['IPAMConfig']['IPv6Address'] == '2001:389::f00d'
 
     @requires_api_version('1.23')
     def test_create_internal_networks(self):

tests/integration/api_volume_test.py

@@ -11,10 +11,10 @@ class TestVolumes(BaseAPIIntegrationTest):
         name = 'perfectcherryblossom'
         self.tmp_volumes.append(name)
         result = self.client.create_volume(name)
-        self.assertIn('Name', result)
-        self.assertEqual(result['Name'], name)
-        self.assertIn('Driver', result)
-        self.assertEqual(result['Driver'], 'local')
+        assert 'Name' in result
+        assert result['Name'] == name
+        assert 'Driver' in result
+        assert result['Driver'] == 'local'
 
     def test_create_volume_invalid_driver(self):
         driver_name = 'invalid.driver'
@@ -27,16 +27,16 @@ class TestVolumes(BaseAPIIntegrationTest):
         self.tmp_volumes.append(name)
         volume_info = self.client.create_volume(name)
         result = self.client.volumes()
-        self.assertIn('Volumes', result)
+        assert 'Volumes' in result
         volumes = result['Volumes']
-        self.assertIn(volume_info, volumes)
+        assert volume_info in volumes
 
     def test_inspect_volume(self):
         name = 'embodimentofscarletdevil'
         self.tmp_volumes.append(name)
         volume_info = self.client.create_volume(name)
         result = self.client.inspect_volume(name)
-        self.assertEqual(volume_info, result)
+        assert volume_info == result
 
     def test_inspect_nonexistent_volume(self):
         name = 'embodimentofscarletdevil'

tests/integration/errors_test.py

 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(
-            client.containers.run("alpine", "echo hello world", remove=True),
-            b'hello world\n'
-        )
+        assert client.containers.run(
+            "alpine", "echo hello world", remove=True
+        ) == b'hello world\n'
 
     def test_run_detach(self):
         client = docker.from_env(version=TEST_API_VERSION)
@@ -24,16 +23,16 @@ class ContainerCollectionTest(BaseIntegrationTest):
 
     def test_run_with_error(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.ContainerError) as cm:
+        with pytest.raises(docker.errors.ContainerError) as cm:
             client.containers.run("alpine", "cat /test", remove=True)
-        assert cm.exception.exit_status == 1
-        assert "cat /test" in str(cm.exception)
-        assert "alpine" in str(cm.exception)
-        assert "No such file or directory" in str(cm.exception)
+        assert cm.value.exit_status == 1
+        assert "cat /test" in cm.exconly()
+        assert "alpine" in cm.exconly()
+        assert "No such file or directory" in cm.exconly()
 
     def test_run_with_image_that_does_not_exist(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.ImageNotFound):
+        with pytest.raises(docker.errors.ImageNotFound):
             client.containers.run("dockerpytest_does_not_exist")
 
     def test_run_with_volume(self):
@@ -52,7 +51,7 @@ class ContainerCollectionTest(BaseIntegrationTest):
             "alpine", "cat /insidecontainer/test",
             volumes=["%s:/insidecontainer" % path]
         )
-        self.assertEqual(out, b'hello\n')
+        assert out == b'hello\n'
 
     def test_run_with_named_volume(self):
         client = docker.from_env(version=TEST_API_VERSION)
@@ -70,7 +69,7 @@ class ContainerCollectionTest(BaseIntegrationTest):
             "alpine", "cat /insidecontainer/test",
             volumes=["somevolume:/insidecontainer"]
         )
-        self.assertEqual(out, b'hello\n')
+        assert out == b'hello\n'
 
     def test_run_with_network(self):
         net_name = random_name()
@@ -170,10 +169,9 @@ class ContainerTest(BaseIntegrationTest):
         self.tmp_containers.append(container.id)
         container.wait()
         image = container.commit()
-        self.assertEqual(
-            client.containers.run(image.id, "cat /test", remove=True),
-            b"hello\n"
-        )
+        assert client.containers.run(
+            image.id, "cat /test", remove=True
+        ) == b"hello\n"
 
     def test_diff(self):
         client = docker.from_env(version=TEST_API_VERSION)

tests/integration/models_images_test.py

@@ -21,16 +21,15 @@ class ImageCollectionTest(BaseIntegrationTest):
     # @pytest.mark.xfail(reason='Engine 1.13 responds with status 500')
     def test_build_with_error(self):
         client = docker.from_env(version=TEST_API_VERSION)
-        with self.assertRaises(docker.errors.BuildError) as cm:
+        with pytest.raises(docker.errors.BuildError) as cm:
             client.images.build(fileobj=io.BytesIO(
                 "FROM alpine\n"
                 "RUN exit 1".encode('ascii')
             ))
-        print(cm.exception)
-        assert str(cm.exception) == (
+        assert (
             "The command '/bin/sh -c exit 1' returned a non-zero code: 1"
-        )
-        assert cm.exception.build_log
+        ) in cm.exconly()
+        assert cm.value.build_log
 
     def test_build_with_multiple_success(self):
         client = docker.from_env(version=TEST_API_VERSION)

tests/integration/models_services_test.py

@@ -6,6 +6,7 @@ from .. import helpers
 from .base import TEST_API_VERSION
 from docker.errors import InvalidArgument
 from docker.types.services import ServiceMode
+import pytest
 
 
 class ServiceTest(unittest.TestCase):
@@ -265,8 +266,7 @@ class ServiceTest(unittest.TestCase):
         while len(tasks) == 0:
             tasks = service.tasks()
         assert len(tasks) == 1
-        with self.assertRaises(InvalidArgument,
-                               msg='Cannot scale a global container'):
+        with pytest.raises(InvalidArgument):
             service.scale(2)
 
         assert len(tasks) == 1

tests/integration/models_swarm_test.py

@@ -4,6 +4,7 @@ import docker
 
 from .. import helpers
 from .base import TEST_API_VERSION
+import pytest
 
 
 class SwarmTest(unittest.TestCase):
@@ -24,11 +25,9 @@ class SwarmTest(unittest.TestCase):
         assert client.swarm.attrs['Spec']['Raft']['SnapshotInterval'] == 10000
         assert client.swarm.id
         assert client.swarm.leave(force=True)
-        with self.assertRaises(docker.errors.APIError) as cm:
+        with pytest.raises(docker.errors.APIError) as cm:
             client.swarm.reload()
         assert (
-            # FIXME: test for both until
-            # https://github.com/docker/docker/issues/29192 is resolved
-            cm.exception.response.status_code == 406 or
-            cm.exception.response.status_code == 503
+            cm.value.response.status_code == 406 or
+            cm.value.response.status_code == 503
         )

tests/integration/regression_test.py

@@ -5,15 +5,16 @@ import docker
 import six
 
 from .base import BaseAPIIntegrationTest, BUSYBOX
+import pytest
 
 
 class TestRegressions(BaseAPIIntegrationTest):
     def test_443_handle_nonchunked_response_in_stream(self):
         dfile = io.BytesIO()
-        with self.assertRaises(docker.errors.APIError) as exc:
+        with pytest.raises(docker.errors.APIError) as exc:
             for line in self.client.build(fileobj=dfile, tag="a/b/c"):
                 pass
-        self.assertEqual(exc.exception.response.status_code, 500)
+        assert exc.value.response.status_code == 500
         dfile.close()
 
     def test_542_truncate_ids_client_side(self):
@@ -21,10 +22,10 @@ class TestRegressions(BaseAPIIntegrationTest):
             self.client.create_container(BUSYBOX, ['true'])
         )
         result = self.client.containers(all=True, trunc=True)
-        self.assertEqual(len(result[0]['Id']), 12)
+        assert len(result[0]['Id']) == 12
 
     def test_647_support_doubleslash_in_image_names(self):
-        with self.assertRaises(docker.errors.APIError):
+        with pytest.raises(docker.errors.APIError):
             self.client.inspect_image('gensokyo.jp//kirisame')
 
     def test_649_handle_timeout_value_none(self):
@@ -53,15 +54,12 @@ class TestRegressions(BaseAPIIntegrationTest):
         )
         self.tmp_containers.append(ctnr)
         self.client.start(ctnr)
-        self.assertEqual(
-            self.client.port(ctnr, 2000)[0]['HostPort'],
-            six.text_type(tcp_port)
-        )
-        self.assertEqual(
-            self.client.port(ctnr, '2000/tcp')[0]['HostPort'],
-            six.text_type(tcp_port)
-        )
-        self.assertEqual(
-            self.client.port(ctnr, '2000/udp')[0]['HostPort'],
-            six.text_type(udp_port)
-        )
+        assert self.client.port(
+            ctnr, 2000
+        )[0]['HostPort'] == six.text_type(tcp_port)
+        assert self.client.port(
+            ctnr, '2000/tcp'
+        )[0]['HostPort'] == six.text_type(tcp_port)
+        assert self.client.port(
+            ctnr, '2000/udp'
+        )[0]['HostPort'] == six.text_type(udp_port)

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(
-            docker.errors.DockerException,
-            lambda: self.client.build('.', container_limits={
+        with pytest.raises(docker.errors.DockerException):
+            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,85 +11,65 @@ class ExecTest(BaseAPIClientTest):
         self.client.exec_create(fake_api.FAKE_CONTAINER_ID, ['ls', '-1'])
 
         args = fake_request.call_args
-        self.assertEqual(
-            'POST',
-            args[0][0], url_prefix + 'containers/{0}/exec'.format(
-                fake_api.FAKE_CONTAINER_ID
-            )
+        assert 'POST' == args[0][0], url_prefix + 'containers/{0}/exec'.format(
+            fake_api.FAKE_CONTAINER_ID
         )
 
-        self.assertEqual(
-            json.loads(args[1]['data']), {
-                'Tty': False,
-                'AttachStdout': True,
-                'Container': fake_api.FAKE_CONTAINER_ID,
-                'Cmd': ['ls', '-1'],
-                'Privileged': False,
-                'AttachStdin': False,
-                'AttachStderr': True,
-                'User': ''
-            }
-        )
+        assert json.loads(args[1]['data']) == {
+            'Tty': False,
+            'AttachStdout': True,
+            'Container': fake_api.FAKE_CONTAINER_ID,
+            'Cmd': ['ls', '-1'],
+            'Privileged': False,
+            'AttachStdin': False,
+            'AttachStderr': True,
+            'User': ''
+        }
 
-        self.assertEqual(args[1]['headers'],
-                         {'Content-Type': 'application/json'})
+        assert args[1]['headers'] == {'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(
-            args[0][1], url_prefix + 'exec/{0}/start'.format(
-                fake_api.FAKE_EXEC_ID
-            )
+        assert args[0][1] == url_prefix + 'exec/{0}/start'.format(
+            fake_api.FAKE_EXEC_ID
         )
 
-        self.assertEqual(
-            json.loads(args[1]['data']), {
-                'Tty': False,
-                'Detach': False,
-            }
-        )
+        assert json.loads(args[1]['data']) == {
+            'Tty': False,
+            'Detach': False,
+        }
 
-        self.assertEqual(
-            args[1]['headers'], {
-                'Content-Type': 'application/json',
-                'Connection': 'Upgrade',
-                'Upgrade': 'tcp'
-            }
-        )
+        assert 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(
-            args[0][1], url_prefix + 'exec/{0}/start'.format(
-                fake_api.FAKE_EXEC_ID
-            )
+        assert args[0][1] == url_prefix + 'exec/{0}/start'.format(
+            fake_api.FAKE_EXEC_ID
         )
 
-        self.assertEqual(
-            json.loads(args[1]['data']), {
-                'Tty': False,
-                'Detach': True
-            }
-        )
+        assert json.loads(args[1]['data']) == {
+            'Tty': False,
+            'Detach': True
+        }
 
-        self.assertEqual(
-            args[1]['headers'], {
-                'Content-Type': 'application/json'
-            }
-        )
+        assert 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(
-            args[0][1], url_prefix + 'exec/{0}/json'.format(
-                fake_api.FAKE_EXEC_ID
-            )
+        assert args[0][1] == url_prefix + 'exec/{0}/json'.format(
+            fake_api.FAKE_EXEC_ID
         )
 
     def test_exec_resize(self):

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(
-            args[0][1],
-            url_prefix + 'images/create'
-        )
-        self.assertEqual(
-            args[1]['params'],
-            {'tag': None, 'fromImage': 'joffrey/test001'}
-        )
-        self.assertFalse(args[1]['stream'])
+        assert args[0][1] == url_prefix + 'images/create'
+        assert args[1]['params'] == {
+            'tag': None, 'fromImage': 'joffrey/test001'
+        }
+        assert not args[1]['stream']
 
     def test_pull_stream(self):
         self.client.pull('joffrey/test001', stream=True)
 
         args = fake_request.call_args
-        self.assertEqual(
-            args[0][1],
-            url_prefix + 'images/create'
-        )
-        self.assertEqual(
-            args[1]['params'],
-            {'tag': None, 'fromImage': 'joffrey/test001'}
-        )
-        self.assertTrue(args[1]['stream'])
+        assert args[0][1] == url_prefix + 'images/create'
+        assert args[1]['params'] == {
+            'tag': None, 'fromImage': 'joffrey/test001'
+        }
+        assert 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(
-                excinfo.value.args[0], 'Resource ID was not provided'
-            )
+            assert 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(
-                docker.utils.compare_version('1.12', self.client._version) >= 0
-            )
+            assert docker.utils.compare_version(
+                '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(
-                post.call_args[0][0],
-                url_prefix + 'networks/create')
+            assert post.call_args[0][0] == url_prefix + 'networks/create'
 
-            self.assertEqual(
-                json.loads(post.call_args[1]['data']),
-                {"Name": "foo"})
+            assert 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(
-                json.loads(post.call_args[1]['data']),
-                {"Name": "foo", "Driver": "bridge", "Options": opts})
+            assert json.loads(post.call_args[1]['data']) == {
+                "Name": "foo", "Driver": "bridge", "Options": opts
+            }
 
             ipam_pool_config = IPAMPool(subnet="192.168.52.0/24",
                                         gateway="192.168.52.254")
@@ -88,21 +84,19 @@ class NetworkTest(BaseAPIClientTest):
             self.client.create_network("bar", driver="bridge",
                                        ipam=ipam_config)
 
-            self.assertEqual(
-                json.loads(post.call_args[1]['data']),
-                {
-                    "Name": "bar",
-                    "Driver": "bridge",
-                    "IPAM": {
-                        "Driver": "default",
-                        "Config": [{
-                            "IPRange": None,
-                            "Gateway": "192.168.52.254",
-                            "Subnet": "192.168.52.0/24",
-                            "AuxiliaryAddresses": None,
-                        }],
-                    }
-                })
+            assert json.loads(post.call_args[1]['data']) == {
+                "Name": "bar",
+                "Driver": "bridge",
+                "IPAM": {
+                    "Driver": "default",
+                    "Config": [{
+                        "IPRange": None,
+                        "Gateway": "192.168.52.254",
+                        "Subnet": "192.168.52.0/24",
+                        "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],
-                         url_prefix + 'networks/{0}'.format(network_id))
+        assert args[0][0] == 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],
-                         url_prefix + 'networks/{0}'.format(network_id))
+        assert args[0][0] == 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(
-            post.call_args[0][0],
-            url_prefix + 'networks/{0}/connect'.format(network_id))
+        assert post.call_args[0][0] == (
+            url_prefix + 'networks/{0}/connect'.format(network_id)
+        )
 
-        self.assertEqual(
-            json.loads(post.call_args[1]['data']),
-            {
-                'Container': container_id,
-                'EndpointConfig': {
-                    'Aliases': ['foo', 'bar'],
-                    'Links': ['baz:quux'],
-                },
-            })
+        assert 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(
-            post.call_args[0][0],
-            url_prefix + 'networks/{0}/disconnect'.format(network_id))
-
-        self.assertEqual(
-            json.loads(post.call_args[1]['data']),
-            {'Container': container_id})
+        assert post.call_args[0][0] == (
+            url_prefix + 'networks/{0}/disconnect'.format(network_id)
+        )
+        assert 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(
-            str(excinfo.value),
-            'Version parameter must be a string or None. Found float'
-        )
+        assert str(
+            excinfo.value
+        ) == '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(
-            url, '{0}{1}'.format(url_prefix, 'hello/somename/world')
-        )
+        assert url == '{0}{1}'.format(url_prefix, 'hello/somename/world')
 
         url = self.client._url(
             '/hello/{0}/world/{1}', 'somename', 'someothername'
         )
-        self.assertEqual(
-            url,
-            '{0}{1}'.format(url_prefix, 'hello/somename/world/someothername')
+        assert url == '{0}{1}'.format(
+            url_prefix, 'hello/somename/world/someothername'
         )
 
         url = self.client._url('/hello/{0}/world', 'some?name')
-        self.assertEqual(
-            url, '{0}{1}'.format(url_prefix, 'hello/some%3Fname/world')
-        )
+        assert url == '{0}{1}'.format(url_prefix, 'hello/some%3Fname/world')
 
         url = self.client._url("/images/{0}/push", "localhost:5000/image")
-        self.assertEqual(
-            url,
-            '{0}{1}'.format(url_prefix, 'images/localhost:5000/image/push')
+        assert url == '{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(
-            url, '{0}{1}'.format(url_base, 'hello/somename/world')
-        )
+        assert 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))
-        self.assertFalse(client._version == "auto")
+        assert isinstance(client._version, six.string_types)
+        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)
-        self.assertEqual(result['SecurityOpt'], security_opt)
-        self.assertRaises(
-            TypeError, self.client.create_host_config, security_opt='wrong'
-        )
+        assert 'SecurityOpt' in result
+        assert result['SecurityOpt'] == security_opt
+        with pytest.raises(TypeError):
+            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) \
-                as client:
+        with APIClient(base_url="http+unix://" + self.socket_file) 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), [
-                str(i).encode() for i in range(50)])
+            assert list(stream) == [
+                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)
-        self.assertEqual(socket._sock.timeout, None)
+        assert socket.timeout is 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)
-        self.assertEqual(socket._sock.timeout, 0.0)
+        assert socket.timeout is None
+        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)
-        self.assertEqual(len(volumes['Volumes']), 2)
+        assert 'Volumes' in volumes
+        assert len(volumes['Volumes']) == 2
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'GET')
-        self.assertEqual(args[0][1], url_prefix + 'volumes')
+        assert args[0][0] == 'GET'
+        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)
-        self.assertEqual(result['Name'], name)
-        self.assertIn('Driver', result)
-        self.assertEqual(result['Driver'], 'local')
+        assert 'Name' in result
+        assert result['Name'] == name
+        assert 'Driver' in result
+        assert result['Driver'] == 'local'
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'POST')
-        self.assertEqual(args[0][1], url_prefix + 'volumes/create')
-        self.assertEqual(json.loads(args[1]['data']), {'Name': name})
+        assert args[0][0] == 'POST'
+        assert args[0][1] == url_prefix + 'volumes/create'
+        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'})
-        self.assertEqual(
-            result["Labels"],
-            {'com.example.some-label': 'some-value'}
-        )
+            'com.example.some-label': 'some-value'
+        })
+        assert result["Labels"] == {
+            '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')
-        self.assertEqual(args[0][1], url_prefix + 'volumes/create')
+        assert args[0][0] == 'POST'
+        assert args[0][1] == url_prefix + 'volumes/create'
         data = json.loads(args[1]['data'])
-        self.assertIn('Driver', data)
-        self.assertEqual(data['Driver'], driver_name)
+        assert 'Driver' in data
+        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)
-        self.assertNotEqual(result['Name'], None)
-        self.assertIn('Driver', result)
-        self.assertEqual(result['Driver'], 'local')
-        self.assertIn('Scope', result)
-        self.assertEqual(result['Scope'], 'local')
+        assert 'Name' in result
+        assert result['Name'] is not None
+        assert 'Driver' in result
+        assert result['Driver'] == 'local'
+        assert 'Scope' in result
+        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)
-        self.assertEqual(result['Name'], name)
-        self.assertIn('Driver', result)
-        self.assertEqual(result['Driver'], 'local')
+        assert 'Name' in result
+        assert result['Name'] == name
+        assert 'Driver' in result
+        assert result['Driver'] == 'local'
         args = fake_request.call_args
 
-        self.assertEqual(args[0][0], 'GET')
-        self.assertEqual(args[0][1], '{0}volumes/{1}'.format(url_prefix, name))
+        assert args[0][0] == 'GET'
+        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')
-        self.assertEqual(args[0][1], '{0}volumes/{1}'.format(url_prefix, name))
+        assert args[0][0] == 'DELETE'
+        assert args[0][1] == '{0}volumes/{1}'.format(url_prefix, name)

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")
-        self.assertEqual(client.api._version, '2.32')
+        assert client.api.base_url == "https://192.168.59.103:2376"
+        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/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 "some error" in str(cm.exception)
+        assert cm.value.exit_status == 1
+        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

 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(
-            CertificateError, match_hostname, self.cert, '192.168.0.25'
-        )
+        with pytest.raises(CertificateError):
+            match_hostname(self.cert, '192.168.0.25')
 
     def test_match_dns_failure(self):
-        self.assertRaises(
-            CertificateError, match_hostname, self.cert, 'foobar.co.uk'
-        )
+        with pytest.raises(CertificateError):
+            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(
-            args[0][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 args[0][1] == (
+            url_prefix + 'nodes/24ifsmvkjbyhk/update?version=1'
         )
+        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):