docker
/
docker-py
mirror of https://github.com/docker/docker-py.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1881 from docker/pytest-asserts 

Use pytest asserts
This commit is contained in:
Joffrey F 2018-01-30 16:29:07 -08:00 committed by GitHub
parent de88ab39c0 3422211309
commit a05922e949
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 1265 additions and 1603 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
tests/integration/api_build_test.py
View File

@ -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')

43
tests/integration/api_client_test.py
View File

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

439
tests/integration/api_container_test.py
View File

@ -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

36
tests/integration/api_exec_test.py
View File

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

5
tests/integration/api_healthcheck_test.py
View File

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

60
tests/integration/api_image_test.py
View File

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

98
tests/integration/api_network_test.py
View File

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

14
tests/integration/api_volume_test.py
View File

@ -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'

5
tests/integration/errors_test.py
View File

@ -1,14 +1,15 @@
from docker.errors import APIError
from .base import BaseAPIIntegrationTest, BUSYBOX
import pytest
class ErrorsTest(BaseAPIIntegrationTest):
def test_api_error_parses_json(self):
container = self.client.create_container(BUSYBOX, ['sleep', '10'])
self.client.start(container['Id'])
with self.assertRaises(APIError) as cm:
with pytest.raises(APIError) as cm:
self.client.remove_container(container['Id'])
explanation = cm.exception.explanation
explanation = cm.value.explanation
assert 'You cannot remove a running container' in explanation
assert '{"message":' not in explanation
self.client.remove_container(container['Id'], force=True)

30
tests/integration/models_containers_test.py
View File

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

9
tests/integration/models_images_test.py
View File

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

4
tests/integration/models_services_test.py
View File

@ -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

9
tests/integration/models_swarm_test.py
View File

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

30
tests/integration/regression_test.py
View File

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

13
tests/unit/api_build_test.py
View File

@ -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

838
tests/unit/api_container_test.py
View File

File diff suppressed because it is too large Load Diff

90
tests/unit/api_exec_test.py
View File

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

38
tests/unit/api_image_test.py
View File

@ -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(

97
tests/unit/api_network_test.py
View File

@ -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
}

79
tests/unit/api_test.py
View File

@ -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

68
tests/unit/api_volume_test.py
View File

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

284
tests/unit/auth_test.py
View File

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

23
tests/unit/client_test.py
View File

@ -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

192
tests/unit/dockertypes_test.py
View File

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

15
tests/unit/models_containers_test.py
View File

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

11
tests/unit/ssladapter_test.py
View File

@ -1,5 +1,6 @@
import unittest
from docker.transport import ssladapter
import pytest
try:
from backports.ssl_match_hostname import (
@ -69,11 +70,9 @@ class MatchHostnameTest(unittest.TestCase):
assert match_hostname(self.cert, 'touhou.gensokyo.jp') is None
def test_match_ip_address_failure(self):
self.assertRaises(
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')

12
tests/unit/swarm_test.py
View File

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

303
tests/unit/utils_test.py
View File

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