Use pytest assertspytest-asserts

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

1 files changed, 218 insertions, 221 deletions

diff --git a/tests/integration/api_container_test.py b/tests/integration/api_container_test.py
index 5d06bc4..4585c44 100644
--- a/tests/integration/api_container_test.py
+++ b/tests/integration/api_container_test.py
@@ -16,6 +16,7 @@ import six
 from .base import BUSYBOX, BaseAPIIntegrationTest
 from .. import helpers
 from ..helpers import requires_api_version
+import re
 
 
 class ListContainersTest(BaseAPIIntegrationTest):
@@ -23,26 +24,26 @@ class ListContainersTest(BaseAPIIntegrationTest):
         res0 = self.client.containers(all=True)
         size = len(res0)
         res1 = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res1)
+        assert 'Id' in res1
         self.client.start(res1['Id'])
         self.tmp_containers.append(res1['Id'])
         res2 = self.client.containers(all=True)
-        self.assertEqual(size + 1, len(res2))
+        assert size + 1 == len(res2)
         retrieved = [x for x in res2 if x['Id'].startswith(res1['Id'])]
-        self.assertEqual(len(retrieved), 1)
+        assert len(retrieved) == 1
         retrieved = retrieved[0]
-        self.assertIn('Command', retrieved)
-        self.assertEqual(retrieved['Command'], six.text_type('true'))
-        self.assertIn('Image', retrieved)
-        self.assertRegex(retrieved['Image'], r'busybox:.*')
-        self.assertIn('Status', retrieved)
+        assert 'Command' in retrieved
+        assert retrieved['Command'] == six.text_type('true')
+        assert 'Image' in retrieved
+        assert re.search(r'busybox:.*', retrieved['Image'])
+        assert 'Status' in retrieved
 
 
 class CreateContainerTest(BaseAPIIntegrationTest):
 
     def test_create(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
 
     def test_create_with_host_pid_mode(self):
@@ -51,14 +52,14 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 pid_mode='host', network_mode='none'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
-        self.assertIn('PidMode', host_config)
-        self.assertEqual(host_config['PidMode'], 'host')
+        assert 'PidMode' in host_config
+        assert host_config['PidMode'] == 'host'
 
     def test_create_with_links(self):
         res0 = self.client.create_container(
@@ -99,15 +100,15 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         container3_id = res2['Id']
         self.tmp_containers.append(container3_id)
         self.client.start(container3_id)
-        self.assertEqual(self.client.wait(container3_id), 0)
+        assert self.client.wait(container3_id) == 0
 
         logs = self.client.logs(container3_id)
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn('{0}_NAME='.format(link_env_prefix1), logs)
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix1), logs)
-        self.assertIn('{0}_NAME='.format(link_env_prefix2), logs)
-        self.assertIn('{0}_ENV_FOO=1'.format(link_env_prefix2), logs)
+        assert '{0}_NAME='.format(link_env_prefix1) in logs
+        assert '{0}_ENV_FOO=1'.format(link_env_prefix1) in logs
+        assert '{0}_NAME='.format(link_env_prefix2) in logs
+        assert '{0}_ENV_FOO=1'.format(link_env_prefix2) in logs
 
     def test_create_with_restart_policy(self):
         container = self.client.create_container(
@@ -120,12 +121,10 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         id = container['Id']
         self.client.start(id)
         self.client.wait(id)
-        with self.assertRaises(docker.errors.APIError) as exc:
+        with pytest.raises(docker.errors.APIError) as exc:
             self.client.remove_container(id)
-        err = exc.exception.explanation
-        self.assertIn(
-            'You cannot remove ', err
-        )
+        err = exc.value.explanation
+        assert 'You cannot remove ' in err
         self.client.remove_container(id, force=True)
 
     def test_create_container_with_volumes_from(self):
@@ -144,7 +143,7 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         container2_id = res1['Id']
         self.tmp_containers.append(container2_id)
         self.client.start(container2_id)
-        with self.assertRaises(docker.errors.DockerException):
+        with pytest.raises(docker.errors.DockerException):
             self.client.create_container(
                 BUSYBOX, 'cat', detach=True, stdin_open=True,
                 volumes_from=vol_names
@@ -169,19 +168,19 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 read_only=True, network_mode='none'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         res = self.client.wait(ctnr)
-        self.assertNotEqual(res, 0)
+        assert res != 0
 
     def create_container_with_name(self):
         res = self.client.create_container(BUSYBOX, 'true', name='foobar')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Name', inspect)
-        self.assertEqual('/foobar', inspect['Name'])
+        assert 'Name' in inspect
+        assert '/foobar' == inspect['Name']
 
     def create_container_privileged(self):
         res = self.client.create_container(
@@ -189,24 +188,24 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 privileged=True, network_mode='none'
             )
         )
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
         # Since Nov 2013, the Privileged flag is no longer part of the
         # container's config exposed via the API (safety concerns?).
         #
         if 'Privileged' in inspect['Config']:
-            self.assertEqual(inspect['Config']['Privileged'], True)
+            assert inspect['Config']['Privileged'] is True
 
     def test_create_with_mac_address(self):
         mac_address_expected = "02:42:ac:11:00:0a"
@@ -217,8 +216,7 @@ class CreateContainerTest(BaseAPIIntegrationTest):
 
         self.client.start(container)
         res = self.client.inspect_container(container['Id'])
-        self.assertEqual(mac_address_expected,
-                         res['NetworkSettings']['MacAddress'])
+        assert mac_address_expected == res['NetworkSettings']['MacAddress']
 
         self.client.kill(id)
 
@@ -236,8 +234,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
         groups = logs.strip().split(' ')
-        self.assertIn('1000', groups)
-        self.assertIn('1001', groups)
+        assert '1000' in groups
+        assert '1001' in groups
 
     @requires_api_version('1.20')
     def test_group_id_strings(self):
@@ -255,8 +253,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
             logs = logs.decode('utf-8')
 
         groups = logs.strip().split(' ')
-        self.assertIn('1000', groups)
-        self.assertIn('1001', groups)
+        assert '1000' in groups
+        assert '1001' in groups
 
     def test_valid_log_driver_and_log_opt(self):
         log_config = docker.types.LogConfig(
@@ -274,8 +272,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], log_config.type)
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        assert container_log_config['Type'] == log_config.type
+        assert container_log_config['Config'] == log_config.config
 
     def test_invalid_log_driver_raises_exception(self):
         log_config = docker.types.LogConfig(
@@ -311,8 +309,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], "json-file")
-        self.assertEqual(container_log_config['Config'], log_config.config)
+        assert container_log_config['Type'] == "json-file"
+        assert container_log_config['Config'] == log_config.config
 
     def test_valid_no_config_specified(self):
         log_config = docker.types.LogConfig(
@@ -330,8 +328,8 @@ class CreateContainerTest(BaseAPIIntegrationTest):
         info = self.client.inspect_container(container)
         container_log_config = info['HostConfig']['LogConfig']
 
-        self.assertEqual(container_log_config['Type'], "json-file")
-        self.assertEqual(container_log_config['Config'], {})
+        assert container_log_config['Type'] == "json-file"
+        assert container_log_config['Config'] == {}
 
     def test_create_with_memory_constraints_with_str(self):
         ctnr = self.client.create_container(
@@ -341,29 +339,29 @@ class CreateContainerTest(BaseAPIIntegrationTest):
                 mem_limit='700M'
             )
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
 
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
         for limit in ['Memory', 'MemorySwap']:
-            self.assertIn(limit, host_config)
+            assert limit in host_config
 
     def test_create_with_memory_constraints_with_int(self):
         ctnr = self.client.create_container(
             BUSYBOX, 'true',
             host_config=self.client.create_host_config(mem_swappiness=40)
         )
-        self.assertIn('Id', ctnr)
+        assert 'Id' in ctnr
         self.tmp_containers.append(ctnr['Id'])
         self.client.start(ctnr)
         inspect = self.client.inspect_container(ctnr)
 
-        self.assertIn('HostConfig', inspect)
+        assert 'HostConfig' in inspect
         host_config = inspect['HostConfig']
-        self.assertIn('MemorySwappiness', host_config)
+        assert 'MemorySwappiness' in host_config
 
     def test_create_with_environment_variable_no_value(self):
         container = self.client.create_container(
@@ -511,7 +509,7 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn(self.filename, logs)
+        assert self.filename in logs
         inspect_data = self.client.inspect_container(container)
         self.check_container_data(inspect_data, True)
 
@@ -533,7 +531,7 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
         if six.PY3:
             logs = logs.decode('utf-8')
-        self.assertIn(self.filename, logs)
+        assert self.filename in logs
 
         inspect_data = self.client.inspect_container(container)
         self.check_container_data(inspect_data, False)
@@ -605,23 +603,23 @@ class VolumeBindTest(BaseAPIIntegrationTest):
 
     def check_container_data(self, inspect_data, rw):
         if docker.utils.compare_version('1.20', self.client._version) < 0:
-            self.assertIn('Volumes', inspect_data)
-            self.assertIn(self.mount_dest, inspect_data['Volumes'])
-            self.assertEqual(
-                self.mount_origin, inspect_data['Volumes'][self.mount_dest]
+            assert 'Volumes' in inspect_data
+            assert self.mount_dest in inspect_data['Volumes']
+            assert (
+                self.mount_origin == inspect_data['Volumes'][self.mount_dest]
             )
-            self.assertIn(self.mount_dest, inspect_data['VolumesRW'])
-            self.assertFalse(inspect_data['VolumesRW'][self.mount_dest])
+            assert self.mount_dest in inspect_data['VolumesRW']
+            assert not inspect_data['VolumesRW'][self.mount_dest]
         else:
-            self.assertIn('Mounts', inspect_data)
+            assert 'Mounts' in inspect_data
             filtered = list(filter(
                 lambda x: x['Destination'] == self.mount_dest,
                 inspect_data['Mounts']
             ))
-            self.assertEqual(len(filtered), 1)
+            assert len(filtered) == 1
             mount_data = filtered[0]
-            self.assertEqual(mount_data['Source'], self.mount_origin)
-            self.assertEqual(mount_data['RW'], rw)
+            assert mount_data['Source'] == self.mount_origin
+            assert mount_data['RW'] == rw
 
     def run_with_volume(self, ro, *args, **kwargs):
         return self.run_container(
@@ -659,7 +657,7 @@ class ArchiveTest(BaseAPIIntegrationTest):
             retrieved_data = helpers.untar_file(destination, 'data.txt')
             if six.PY3:
                 retrieved_data = retrieved_data.decode('utf-8')
-            self.assertEqual(data, retrieved_data.strip())
+            assert data == retrieved_data.strip()
 
     def test_get_file_stat_from_container(self):
         data = 'The Maid and the Pocket Watch of Blood'
@@ -671,10 +669,10 @@ class ArchiveTest(BaseAPIIntegrationTest):
         self.client.start(ctnr)
         self.client.wait(ctnr)
         strm, stat = self.client.get_archive(ctnr, '/vol1/data.txt')
-        self.assertIn('name', stat)
-        self.assertEqual(stat['name'], 'data.txt')
-        self.assertIn('size', stat)
-        self.assertEqual(stat['size'], len(data))
+        assert 'name' in stat
+        assert stat['name'] == 'data.txt'
+        assert 'size' in stat
+        assert stat['size'] == len(data)
 
     def test_copy_file_to_container(self):
         data = b'Deaf To All But The Song'
@@ -697,7 +695,7 @@ class ArchiveTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
             data = data.decode('utf-8')
-        self.assertEqual(logs.strip(), data)
+        assert logs.strip() == data
 
     def test_copy_directory_to_container(self):
         files = ['a.py', 'b.py', 'foo/b.py']
@@ -715,10 +713,10 @@ class ArchiveTest(BaseAPIIntegrationTest):
         if six.PY3:
             logs = logs.decode('utf-8')
         results = logs.strip().split()
-        self.assertIn('a.py', results)
-        self.assertIn('b.py', results)
-        self.assertIn('foo/', results)
-        self.assertIn('bar/', results)
+        assert 'a.py' in results
+        assert 'b.py' in results
+        assert 'foo/' in results
+        assert 'bar/' in results
 
 
 class RenameContainerTest(BaseAPIIntegrationTest):
@@ -726,49 +724,49 @@ class RenameContainerTest(BaseAPIIntegrationTest):
         version = self.client.version()['Version']
         name = 'hong_meiling'
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.rename(res, name)
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Name', inspect)
+        assert 'Name' in inspect
         if version == '1.5.0':
-            self.assertEqual(name, inspect['Name'])
+            assert name == inspect['Name']
         else:
-            self.assertEqual('/{0}'.format(name), inspect['Name'])
+            assert '/{0}'.format(name) == inspect['Name']
 
 
 class StartContainerTest(BaseAPIIntegrationTest):
     def test_start_container(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res['Id'])
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
 
     def test_start_container_with_dict_instead_of_id(self):
         res = self.client.create_container(BUSYBOX, 'true')
-        self.assertIn('Id', res)
+        assert 'Id' in res
         self.tmp_containers.append(res['Id'])
         self.client.start(res)
         inspect = self.client.inspect_container(res['Id'])
-        self.assertIn('Config', inspect)
-        self.assertIn('Id', inspect)
-        self.assertTrue(inspect['Id'].startswith(res['Id']))
-        self.assertIn('Image', inspect)
-        self.assertIn('State', inspect)
-        self.assertIn('Running', inspect['State'])
+        assert 'Config' in inspect
+        assert 'Id' in inspect
+        assert inspect['Id'].startswith(res['Id'])
+        assert 'Image' in inspect
+        assert 'State' in inspect
+        assert 'Running' in inspect['State']
         if not inspect['State']['Running']:
-            self.assertIn('ExitCode', inspect['State'])
-            self.assertEqual(inspect['State']['ExitCode'], 0)
+            assert 'ExitCode' in inspect['State']
+            assert inspect['State']['ExitCode'] == 0
 
     def test_run_shlex_commands(self):
         commands = [
@@ -788,7 +786,7 @@ class StartContainerTest(BaseAPIIntegrationTest):
             self.client.start(id)
             self.tmp_containers.append(id)
             exitcode = self.client.wait(id)
-            self.assertEqual(exitcode, 0, msg=cmd)
+            assert exitcode == 0, cmd
 
 
 class WaitTest(BaseAPIIntegrationTest):
@@ -798,12 +796,12 @@ class WaitTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         inspect = self.client.inspect_container(id)
-        self.assertIn('Running', inspect['State'])
-        self.assertEqual(inspect['State']['Running'], False)
-        self.assertIn('ExitCode', inspect['State'])
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        assert 'Running' in inspect['State']
+        assert inspect['State']['Running'] is False
+        assert 'ExitCode' in inspect['State']
+        assert inspect['State']['ExitCode'] == exitcode
 
     def test_wait_with_dict_instead_of_id(self):
         res = self.client.create_container(BUSYBOX, ['sleep', '3'])
@@ -811,12 +809,12 @@ class WaitTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(res)
         exitcode = self.client.wait(res)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         inspect = self.client.inspect_container(res)
-        self.assertIn('Running', inspect['State'])
-        self.assertEqual(inspect['State']['Running'], False)
-        self.assertIn('ExitCode', inspect['State'])
-        self.assertEqual(inspect['State']['ExitCode'], exitcode)
+        assert 'Running' in inspect['State']
+        assert inspect['State']['Running'] is False
+        assert 'ExitCode' in inspect['State']
+        assert inspect['State']['ExitCode'] == exitcode
 
     @requires_api_version('1.30')
     def test_wait_with_condition(self):
@@ -844,9 +842,9 @@ class LogsTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id)
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_tail_option(self):
         snippet = '''Line1
@@ -858,9 +856,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id, tail=1)
-        self.assertEqual(logs, 'Line2\n'.encode(encoding='ascii'))
+        assert logs == 'Line2\n'.encode(encoding='ascii')
 
     def test_logs_streaming_and_follow(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -875,9 +873,9 @@ Line2'''
             logs += chunk
 
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
 
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_dict_instead_of_id(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -888,9 +886,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(container)
-        self.assertEqual(logs, (snippet + '\n').encode(encoding='ascii'))
+        assert logs == (snippet + '\n').encode(encoding='ascii')
 
     def test_logs_with_tail_0(self):
         snippet = 'Flowering Nights (Sakuya Iyazoi)'
@@ -901,9 +899,9 @@ Line2'''
         self.tmp_containers.append(id)
         self.client.start(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         logs = self.client.logs(id, tail=0)
-        self.assertEqual(logs, ''.encode(encoding='ascii'))
+        assert logs == ''.encode(encoding='ascii')
 
     @requires_api_version('1.35')
     def test_logs_with_until(self):
@@ -929,12 +927,12 @@ class DiffTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         diff = self.client.diff(id)
         test_diff = [x for x in diff if x.get('Path', None) == '/test']
-        self.assertEqual(len(test_diff), 1)
-        self.assertIn('Kind', test_diff[0])
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        assert len(test_diff) == 1
+        assert 'Kind' in test_diff[0]
+        assert test_diff[0]['Kind'] == 1
 
     def test_diff_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['touch', '/test'])
@@ -942,12 +940,12 @@ class DiffTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         exitcode = self.client.wait(id)
-        self.assertEqual(exitcode, 0)
+        assert exitcode == 0
         diff = self.client.diff(container)
         test_diff = [x for x in diff if x.get('Path', None) == '/test']
-        self.assertEqual(len(test_diff), 1)
-        self.assertIn('Kind', test_diff[0])
-        self.assertEqual(test_diff[0]['Kind'], 1)
+        assert len(test_diff) == 1
+        assert 'Kind' in test_diff[0]
+        assert test_diff[0]['Kind'] == 1
 
 
 class StopTest(BaseAPIIntegrationTest):
@@ -958,23 +956,23 @@ class StopTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.stop(id, timeout=2)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_stop_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
-        self.assertIn('Id', container)
+        assert 'Id' in container
         id = container['Id']
         self.client.start(container)
         self.tmp_containers.append(id)
         self.client.stop(container, timeout=2)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'Running' in state
+        assert state['Running'] is False
 
 
 class KillTest(BaseAPIIntegrationTest):
@@ -985,12 +983,12 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_kill_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
@@ -999,12 +997,12 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(container)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False
 
     def test_kill_with_signal(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1014,14 +1012,14 @@ class KillTest(BaseAPIIntegrationTest):
             id, signal=signal.SIGKILL if not IS_WINDOWS_PLATFORM else 9
         )
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
     def test_kill_with_signal_name(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1029,14 +1027,14 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id, signal='SIGKILL')
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
     def test_kill_with_signal_integer(self):
         id = self.client.create_container(BUSYBOX, ['sleep', '60'])
@@ -1044,14 +1042,14 @@ class KillTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.kill(id, signal=9)
         exitcode = self.client.wait(id)
-        self.assertNotEqual(exitcode, 0)
+        assert exitcode != 0
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertNotEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], False, state)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] != 0
+        assert 'Running' in state
+        assert state['Running'] is False, state
 
 
 class PortTest(BaseAPIIntegrationTest):
@@ -1079,8 +1077,8 @@ class PortTest(BaseAPIIntegrationTest):
 
             ip, host_port = port_binding['HostIp'], port_binding['HostPort']
 
-            self.assertEqual(ip, port_bindings[port][0])
-            self.assertEqual(host_port, port_bindings[port][1])
+            assert ip == port_bindings[port][0]
+            assert host_port == port_bindings[port][1]
 
         self.client.kill(id)
 
@@ -1116,13 +1114,12 @@ class ContainerTopTest(BaseAPIIntegrationTest):
 
         self.client.start(container)
         res = self.client.top(container, 'waux')
-        self.assertEqual(
-            res['Titles'],
-            ['USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
-                'TTY', 'STAT', 'START', 'TIME', 'COMMAND'],
-        )
-        self.assertEqual(len(res['Processes']), 1)
-        self.assertEqual(res['Processes'][0][10], 'sleep 60')
+        assert res['Titles'] == [
+            'USER', 'PID', '%CPU', '%MEM', 'VSZ', 'RSS',
+            'TTY', 'STAT', 'START', 'TIME', 'COMMAND'
+        ]
+        assert len(res['Processes']) == 1
+        assert res['Processes'][0][10] == 'sleep 60'
 
 
 class RestartContainerTest(BaseAPIIntegrationTest):
@@ -1132,37 +1129,37 @@ class RestartContainerTest(BaseAPIIntegrationTest):
         self.client.start(id)
         self.tmp_containers.append(id)
         info = self.client.inspect_container(id)
-        self.assertIn('State', info)
-        self.assertIn('StartedAt', info['State'])
+        assert 'State' in info
+        assert 'StartedAt' in info['State']
         start_time1 = info['State']['StartedAt']
         self.client.restart(id, timeout=2)
         info2 = self.client.inspect_container(id)
-        self.assertIn('State', info2)
-        self.assertIn('StartedAt', info2['State'])
+        assert 'State' in info2
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
-        self.assertIn('Running', info2['State'])
-        self.assertEqual(info2['State']['Running'], True)
+        assert start_time1 != start_time2
+        assert 'Running' in info2['State']
+        assert info2['State']['Running'] is True
         self.client.kill(id)
 
     def test_restart_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['sleep', '9999'])
-        self.assertIn('Id', container)
+        assert 'Id' in container
         id = container['Id']
         self.client.start(container)
         self.tmp_containers.append(id)
         info = self.client.inspect_container(id)
-        self.assertIn('State', info)
-        self.assertIn('StartedAt', info['State'])
+        assert 'State' in info
+        assert 'StartedAt' in info['State']
         start_time1 = info['State']['StartedAt']
         self.client.restart(container, timeout=2)
         info2 = self.client.inspect_container(id)
-        self.assertIn('State', info2)
-        self.assertIn('StartedAt', info2['State'])
+        assert 'State' in info2
+        assert 'StartedAt' in info2['State']
         start_time2 = info2['State']['StartedAt']
-        self.assertNotEqual(start_time1, start_time2)
-        self.assertIn('Running', info2['State'])
-        self.assertEqual(info2['State']['Running'], True)
+        assert start_time1 != start_time2
+        assert 'Running' in info2['State']
+        assert info2['State']['Running'] is True
         self.client.kill(id)
 
 
@@ -1175,7 +1172,7 @@ class RemoveContainerTest(BaseAPIIntegrationTest):
         self.client.remove_container(id)
         containers = self.client.containers(all=True)
         res = [x for x in containers if 'Id' in x and x['Id'].startswith(id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
     def test_remove_with_dict_instead_of_id(self):
         container = self.client.create_container(BUSYBOX, ['true'])
@@ -1185,7 +1182,7 @@ class RemoveContainerTest(BaseAPIIntegrationTest):
         self.client.remove_container(container)
         containers = self.client.containers(all=True)
         res = [x for x in containers if 'Id' in x and x['Id'].startswith(id)]
-        self.assertEqual(len(res), 0)
+        assert len(res) == 0
 
 
 class AttachContainerTest(BaseAPIIntegrationTest):
@@ -1196,7 +1193,7 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(id)
         self.client.start(id)
         sock = self.client.attach_socket(container, ws=False)
-        self.assertTrue(sock.fileno() > -1)
+        assert sock.fileno() > -1
 
     def test_run_container_reading_socket(self):
         line = 'hi there and stuff and things, words!'
@@ -1213,9 +1210,9 @@ class AttachContainerTest(BaseAPIIntegrationTest):
         self.client.start(container)
 
         next_size = next_frame_size(pty_stdout)
-        self.assertEqual(next_size, len(line))
+        assert next_size == len(line)
         data = read_exactly(pty_stdout, next_size)
-        self.assertEqual(data.decode('utf-8'), line)
+        assert data.decode('utf-8') == line
 
     def test_attach_no_stream(self):
         container = self.client.create_container(
@@ -1235,25 +1232,25 @@ class PauseTest(BaseAPIIntegrationTest):
         self.client.start(container)
         self.client.pause(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], True)
-        self.assertIn('Paused', state)
-        self.assertEqual(state['Paused'], True)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] == 0
+        assert 'Running' in state
+        assert state['Running'] is True
+        assert 'Paused' in state
+        assert state['Paused'] is True
 
         self.client.unpause(id)
         container_info = self.client.inspect_container(id)
-        self.assertIn('State', container_info)
+        assert 'State' in container_info
         state = container_info['State']
-        self.assertIn('ExitCode', state)
-        self.assertEqual(state['ExitCode'], 0)
-        self.assertIn('Running', state)
-        self.assertEqual(state['Running'], True)
-        self.assertIn('Paused', state)
-        self.assertEqual(state['Paused'], False)
+        assert 'ExitCode' in state
+        assert state['ExitCode'] == 0
+        assert 'Running' in state
+        assert state['Running'] is True
+        assert 'Paused' in state
+        assert state['Paused'] is False
 
 
 class PruneTest(BaseAPIIntegrationTest):
@@ -1283,10 +1280,10 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
         response = self.client.stats(container, stream=0)
         self.client.kill(container)
 
-        self.assertEqual(type(response), dict)
+        assert type(response) == dict
         for key in ['read', 'networks', 'precpu_stats', 'cpu_stats',
                     'memory_stats', 'blkio_stats']:
-            self.assertIn(key, response)
+            assert key in response
 
         @requires_api_version('1.17')
         def test_get_container_stats_stream(self):
@@ -1297,10 +1294,10 @@ class GetContainerStatsTest(BaseAPIIntegrationTest):
             self.client.start(container)
             stream = self.client.stats(container)
             for chunk in stream:
-                self.assertEqual(type(chunk), dict)
+                assert type(chunk) == dict
                 for key in ['read', 'network', 'precpu_stats', 'cpu_stats',
                             'memory_stats', 'blkio_stats']:
-                    self.assertIn(key, chunk)
+                    assert key in chunk
 
 
 class ContainerUpdateTest(BaseAPIIntegrationTest):
@@ -1317,7 +1314,7 @@ class ContainerUpdateTest(BaseAPIIntegrationTest):
         self.client.start(container)
         self.client.update_container(container, mem_limit=new_mem_limit)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['Memory'], new_mem_limit)
+        assert inspect_data['HostConfig']['Memory'] == new_mem_limit
 
     @requires_api_version('1.23')
     def test_restart_policy_update(self):
@@ -1340,12 +1337,12 @@ class ContainerUpdateTest(BaseAPIIntegrationTest):
         self.client.update_container(container,
                                      restart_policy=new_restart_policy)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(
-            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'],
+        assert (
+            inspect_data['HostConfig']['RestartPolicy']['MaximumRetryCount'] ==
             new_restart_policy['MaximumRetryCount']
         )
-        self.assertEqual(
-            inspect_data['HostConfig']['RestartPolicy']['Name'],
+        assert (
+            inspect_data['HostConfig']['RestartPolicy']['Name'] ==
             new_restart_policy['Name']
         )
 
@@ -1362,7 +1359,7 @@ class ContainerCPUTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['CpuShares'], 512)
+        assert inspect_data['HostConfig']['CpuShares'] == 512
 
     @requires_api_version('1.18')
     def test_container_cpuset(self):
@@ -1375,7 +1372,7 @@ class ContainerCPUTest(BaseAPIIntegrationTest):
         self.tmp_containers.append(container)
         self.client.start(container)
         inspect_data = self.client.inspect_container(container)
-        self.assertEqual(inspect_data['HostConfig']['CpusetCpus'], cpuset_cpus)
+        assert inspect_data['HostConfig']['CpusetCpus'] == cpuset_cpus
 
     @requires_api_version('1.25')
     def test_create_with_runtime(self):
@@ -1419,11 +1416,11 @@ class LinkTest(BaseAPIIntegrationTest):
         # Link is gone
         containers = self.client.containers(all=True)
         retrieved = [x for x in containers if link_name in x['Names']]
-        self.assertEqual(len(retrieved), 0)
+        assert len(retrieved) == 0
 
         # Containers are still there
         retrieved = [
             x for x in containers if x['Id'].startswith(container1_id) or
             x['Id'].startswith(container2_id)
         ]
-        self.assertEqual(len(retrieved), 2)
+        assert len(retrieved) == 2