Reorganize test directories

More clearly separate unit and integration tests
Allow splitting into multiple files
Cleaner
Signed-off-by: Joffrey F <joffrey@docker.com>

Makefile

@@ -17,21 +17,21 @@ build-dind-certs:
 test: flake8 unit-test unit-test-py3 integration-dind integration-dind-ssl
 
 unit-test: build
-	docker run docker-py py.test tests/test.py tests/utils_test.py
+	docker run docker-py py.test tests/unit
 
 unit-test-py3: build-py3
-	docker run docker-py3 py.test tests/test.py tests/utils_test.py
+	docker run docker-py3 py.test tests/unit
 
 integration-test: build
-	docker run -v /var/run/docker.sock:/var/run/docker.sock docker-py py.test tests/integration_test.py
+	docker run -v /var/run/docker.sock:/var/run/docker.sock docker-py py.test tests/integration
 
 integration-test-py3: build-py3
-	docker run -v /var/run/docker.sock:/var/run/docker.sock docker-py3 py.test tests/integration_test.py
+	docker run -v /var/run/docker.sock:/var/run/docker.sock docker-py3 py.test tests/integration
 
 integration-dind: build build-py3
 	docker run -d --name dpy-dind --env="DOCKER_HOST=tcp://localhost:2375" --privileged dockerswarm/dind:1.8.1 docker -d -H tcp://0.0.0.0:2375
-	docker run --volumes-from dpy-dind --env="DOCKER_HOST=tcp://docker:2375" --link=dpy-dind:docker docker-py py.test tests/integration_test.py
-	docker run --volumes-from dpy-dind --env="DOCKER_HOST=tcp://docker:2375" --link=dpy-dind:docker docker-py3 py.test tests/integration_test.py
+	docker run --env="DOCKER_HOST=tcp://docker:2375" --link=dpy-dind:docker docker-py py.test tests/integration
+	docker run --env="DOCKER_HOST=tcp://docker:2375" --link=dpy-dind:docker docker-py3 py.test tests/integration
 	docker rm -vf dpy-dind
 
 integration-dind-ssl: build-dind-certs build build-py3

tests/base.py

@@ -21,3 +21,28 @@ def requires_api_version(version):
         ),
         reason="API version is too low (< {0})".format(version)
     )
+
+
+class Cleanup(object):
+    if sys.version_info < (2, 7):
+        # Provide a basic implementation of addCleanup for Python < 2.7
+        def __init__(self, *args, **kwargs):
+            super(Cleanup, self).__init__(*args, **kwargs)
+            self._cleanups = []
+
+        def tearDown(self):
+            super(Cleanup, self).tearDown()
+            ok = True
+            while self._cleanups:
+                fn, args, kwargs = self._cleanups.pop(-1)
+                try:
+                    fn(*args, **kwargs)
+                except KeyboardInterrupt:
+                    raise
+                except:
+                    ok = False
+            if not ok:
+                raise
+
+        def addCleanup(self, function, *args, **kwargs):
+            self._cleanups.append((function, args, kwargs))

tests/integration/__init__.py

+# flake8: noqa
+
+# FIXME: crutch while we transition to the new folder architecture
+# Remove imports when merged in master and Jenkins is updated to find the
+# tests in the new location.
+from .api_test import *
+from .build_test import *
+from .container_test import *
+from .exec_test import *
+from .image_test import *
+from .network_test import *
+from .regression_test import *
+from .volume_test import *

tests/integration/api_test.py

+import base64
+import json
+import os
+import shutil
+import tempfile
+import time
+import unittest
+import warnings
+
+import docker
+import six
+
+BUSYBOX = 'busybox:buildroot-2014.02'
+EXEC_DRIVER = []
+
+
+def exec_driver_is_native():
+    global EXEC_DRIVER
+    if not EXEC_DRIVER:
+        c = docker_client()
+        EXEC_DRIVER = c.info()['ExecutionDriver']
+        c.close()
+    return EXEC_DRIVER.startswith('native')
+
+
+def docker_client(**kwargs):
+    return docker.Client(**docker_client_kwargs(**kwargs))
+
+
+def docker_client_kwargs(**kwargs):
+    client_kwargs = docker.utils.kwargs_from_env(assert_hostname=False)
+    client_kwargs.update(kwargs)
+    return client_kwargs
+
+
+def setup_module():
+    warnings.simplefilter('error')
+    c = docker_client()
+    try:
+        c.inspect_image(BUSYBOX)
+    except docker.errors.NotFound:
+        os.write(2, "\npulling busybox\n".encode('utf-8'))
+        for data in c.pull(BUSYBOX, stream=True):
+            data = json.loads(data.decode('utf-8'))
+            os.write(2, ("%c[2K\r" % 27).encode('utf-8'))
+            status = data.get("status")
+            progress = data.get("progress")
+            detail = "{0} - {1}".format(status, progress).encode('utf-8')
+            os.write(2, detail)
+        os.write(2, "\npulled busybox\n".encode('utf-8'))
+
+        # Double make sure we now have busybox
+        c.inspect_image(BUSYBOX)
+    c.close()
+
+
+class BaseTestCase(unittest.TestCase):
+    tmp_imgs = []
+    tmp_containers = []
+    tmp_folders = []
+    tmp_volumes = []
+
+    def setUp(self):
+        if six.PY2:
+            self.assertRegex = self.assertRegexpMatches
+            self.assertCountEqual = self.assertItemsEqual
+        self.client = docker_client(timeout=60)
+        self.tmp_imgs = []
+        self.tmp_containers = []
+        self.tmp_folders = []
+        self.tmp_volumes = []
+        self.tmp_networks = []
+
+    def tearDown(self):
+        for img in self.tmp_imgs:
+            try:
+                self.client.remove_image(img)
+            except docker.errors.APIError:
+                pass
+        for container in self.tmp_containers:
+            try:
+                self.client.stop(container, timeout=1)
+                self.client.remove_container(container)
+            except docker.errors.APIError:
+                pass
+        for network in self.tmp_networks:
+            try:
+                self.client.remove_network(network)
+            except docker.errors.APIError:
+                pass
+        for folder in self.tmp_folders:
+            shutil.rmtree(folder)
+
+        for volume in self.tmp_volumes:
+            try:
+                self.client.remove_volume(volume)
+            except docker.errors.APIError:
+                pass
+
+        self.client.close()
+
+    def run_container(self, *args, **kwargs):
+        container = self.client.create_container(*args, **kwargs)
+        self.tmp_containers.append(container)
+        self.client.start(container)
+        exitcode = self.client.wait(container)
+
+        if exitcode != 0:
+            output = self.client.logs(container)
+            raise Exception(
+                "Container exited with code {}:\n{}"
+                .format(exitcode, output))
+
+        return container
+
+
+#########################
+#   INFORMATION TESTS   #
+#########################
+
+
+class InformationTest(BaseTestCase):
+    def test_version(self):
+        res = self.client.version()
+        self.assertIn('GoVersion', res)
+        self.assertIn('Version', res)
+        self.assertEqual(len(res['Version'].split('.')), 3)
+
+    def test_info(self):
+        res = self.client.info()
+        self.assertIn('Containers', res)
+        self.assertIn('Images', res)
+        self.assertIn('Debug', res)
+
+    def test_search(self):
+        self.client = docker_client(timeout=10)
+        res = self.client.search('busybox')
+        self.assertTrue(len(res) >= 1)
+        base_img = [x for x in res if x['name'] == 'busybox']
+        self.assertEqual(len(base_img), 1)
+        self.assertIn('description', base_img[0])
+
+
+#################
+#  LINKS TESTS  #
+#################
+
+
+class LinkTest(BaseTestCase):
+    def test_remove_link(self):
+        # Create containers
+        container1 = self.client.create_container(
+            BUSYBOX, 'cat', detach=True, stdin_open=True
+        )
+        container1_id = container1['Id']
+        self.tmp_containers.append(container1_id)
+        self.client.start(container1_id)
+
+        # Create Link
+        # we don't want the first /
+        link_path = self.client.inspect_container(container1_id)['Name'][1:]
+        link_alias = 'mylink'
+
+        container2 = self.client.create_container(
+            BUSYBOX, 'cat', host_config=self.client.create_host_config(
+                links={link_path: link_alias}, network_mode='none'
+            )
+        )
+        container2_id = container2['Id']
+        self.tmp_containers.append(container2_id)
+        self.client.start(container2_id)
+
+        # Remove link
+        linked_name = self.client.inspect_container(container2_id)['Name'][1:]
+        link_name = '%s/%s' % (linked_name, link_alias)
+        self.client.remove_container(link_name, link=True)
+
+        # 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)
+
+        # 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)
+
+
+#######################
+#  PY SPECIFIC TESTS  #
+#######################
+
+class LoadConfigTest(BaseTestCase):
+    def test_load_legacy_config(self):
+        folder = tempfile.mkdtemp()
+        self.tmp_folders.append(folder)
+        cfg_path = os.path.join(folder, '.dockercfg')
+        f = open(cfg_path, 'w')
+        auth_ = base64.b64encode(b'sakuya:izayoi').decode('ascii')
+        f.write('auth = {0}\n'.format(auth_))
+        f.write('email = sakuya@scarlet.net')
+        f.close()
+        cfg = docker.auth.load_config(cfg_path)
+        self.assertNotEqual(cfg[docker.auth.INDEX_NAME], 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)
+
+    def test_load_json_config(self):
+        folder = tempfile.mkdtemp()
+        self.tmp_folders.append(folder)
+        cfg_path = os.path.join(folder, '.dockercfg')
+        f = open(os.path.join(folder, '.dockercfg'), 'w')
+        auth_ = base64.b64encode(b'sakuya:izayoi').decode('ascii')
+        email_ = 'sakuya@scarlet.net'
+        f.write('{{"{0}": {{"auth": "{1}", "email": "{2}"}}}}\n'.format(
+            docker.auth.INDEX_URL, auth_, email_))
+        f.close()
+        cfg = docker.auth.load_config(cfg_path)
+        self.assertNotEqual(cfg[docker.auth.INDEX_URL], 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)
+
+
+class AutoDetectVersionTest(unittest.TestCase):
+    def test_client_init(self):
+        client = docker_client(version='auto')
+        client_version = client._version
+        api_version = client.version(api_version=False)['ApiVersion']
+        self.assertEqual(client_version, api_version)
+        api_version_2 = client.version()['ApiVersion']
+        self.assertEqual(client_version, api_version_2)
+        client.close()
+
+    def test_auto_client(self):
+        client = docker.AutoVersionClient(**docker_client_kwargs())
+        client_version = client._version
+        api_version = client.version(api_version=False)['ApiVersion']
+        self.assertEqual(client_version, api_version)
+        api_version_2 = client.version()['ApiVersion']
+        self.assertEqual(client_version, api_version_2)
+        client.close()
+        with self.assertRaises(docker.errors.DockerException):
+            docker.AutoVersionClient(**docker_client_kwargs(version='1.11'))
+
+
+class ConnectionTimeoutTest(unittest.TestCase):
+    def setUp(self):
+        self.timeout = 0.5
+        self.client = docker.client.Client(base_url='http://192.168.10.2:4243',
+                                           timeout=self.timeout)
+
+    def test_timeout(self):
+        start = time.time()
+        res = None
+        # This call isn't supposed to complete, and it should fail fast.
+        try:
+            res = self.client.inspect_container('id')
+        except:
+            pass
+        end = time.time()
+        self.assertTrue(res is None)
+        self.assertTrue(end - start < 2 * self.timeout)
+
+
+class UnixconnTest(unittest.TestCase):
+    """
+    Test UNIX socket connection adapter.
+    """
+
+    def test_resource_warnings(self):
+        """
+        Test no warnings are produced when using the client.
+        """
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+
+            client = docker_client()
+            client.images()
+            client.close()
+            del client
+
+            assert len(w) == 0, \
+                "No warnings produced: {0}".format(w[0].message)

tests/integration/build_test.py

+import io
+import json
+import os
+import shutil
+import tempfile
+
+import six
+
+from . import api_test
+from ..base import requires_api_version
+
+
+class BuildTest(api_test.BaseTestCase):
+    def test_build_streaming(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+        stream = self.client.build(fileobj=script, stream=True)
+        logs = ''
+        for chunk in stream:
+            if six.PY3:
+                chunk = chunk.decode('utf-8')
+            json.loads(chunk)  # ensure chunk is a single, valid JSON blob
+            logs += chunk
+        self.assertNotEqual(logs, '')
+
+    def test_build_from_stringio(self):
+        if six.PY3:
+            return
+        script = io.StringIO(six.text_type('\n').join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]))
+        stream = self.client.build(fileobj=script, stream=True)
+        logs = ''
+        for chunk in stream:
+            if six.PY3:
+                chunk = chunk.decode('utf-8')
+            logs += chunk
+        self.assertNotEqual(logs, '')
+
+    @requires_api_version('1.8')
+    def test_build_with_dockerignore(self):
+        base_dir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, base_dir)
+
+        with open(os.path.join(base_dir, 'Dockerfile'), 'w') as f:
+            f.write("\n".join([
+                'FROM busybox',
+                'MAINTAINER docker-py',
+                'ADD . /test',
+            ]))
+
+        with open(os.path.join(base_dir, '.dockerignore'), 'w') as f:
+            f.write("\n".join([
+                'ignored',
+                'Dockerfile',
+                '.dockerignore',
+                '',  # empty line
+            ]))
+
+        with open(os.path.join(base_dir, 'not-ignored'), 'w') as f:
+            f.write("this file should not be ignored")
+
+        subdir = os.path.join(base_dir, 'ignored', 'subdir')
+        os.makedirs(subdir)
+        with open(os.path.join(subdir, 'file'), 'w') as f:
+            f.write("this file should be ignored")
+
+        tag = 'docker-py-test-build-with-dockerignore'
+        stream = self.client.build(
+            path=base_dir,
+            tag=tag,
+        )
+        for chunk in stream:
+            pass
+
+        c = self.client.create_container(tag, ['ls', '-1A', '/test'])
+        self.client.start(c)
+        self.client.wait(c)
+        logs = self.client.logs(c)
+
+        if six.PY3:
+            logs = logs.decode('utf-8')
+
+        self.assertEqual(
+            list(filter(None, logs.split('\n'))),
+            ['not-ignored'],
+        )

tests/integration/exec_test.py

+import pytest
+
+from . import api_test
+
+BUSYBOX = api_test.BUSYBOX
+
+
+class ExecTest(api_test.BaseTestCase):
+    def test_execute_command(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        res = self.client.exec_create(id, ['echo', 'hello'])
+        self.assertIn('Id', res)
+
+        exec_log = self.client.exec_start(res)
+        self.assertEqual(exec_log, b'hello\n')
+
+    def test_exec_command_string(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        res = self.client.exec_create(id, 'echo hello world')
+        self.assertIn('Id', res)
+
+        exec_log = self.client.exec_start(res)
+        self.assertEqual(exec_log, b'hello world\n')
+
+    def test_exec_command_as_user(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        res = self.client.exec_create(id, 'whoami', user='default')
+        self.assertIn('Id', res)
+
+        exec_log = self.client.exec_start(res)
+        self.assertEqual(exec_log, b'default\n')
+
+    def test_exec_command_as_root(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        res = self.client.exec_create(id, 'whoami')
+        self.assertIn('Id', res)
+
+        exec_log = self.client.exec_start(res)
+        self.assertEqual(exec_log, b'root\n')
+
+    def test_exec_command_streaming(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        exec_id = self.client.exec_create(id, ['echo', 'hello\nworld'])
+        self.assertIn('Id', exec_id)
+
+        res = b''
+        for chunk in self.client.exec_start(exec_id, stream=True):
+            res += chunk
+        self.assertEqual(res, b'hello\nworld\n')
+
+    def test_exec_inspect(self):
+        if not api_test.exec_driver_is_native():
+            pytest.skip('Exec driver not native')
+
+        container = self.client.create_container(BUSYBOX, 'cat',
+                                                 detach=True, stdin_open=True)
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+
+        exec_id = self.client.exec_create(id, ['mkdir', '/does/not/exist'])
+        self.assertIn('Id', 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)

tests/integration/image_test.py

+import contextlib
+import json
+import shutil
+import socket
+import tarfile
+import tempfile
+import threading
+
+import pytest
+import six
+from six.moves import BaseHTTPServer
+from six.moves import socketserver
+
+
+import docker
+
+from . import api_test
+
+BUSYBOX = api_test.BUSYBOX
+
+
+class ListImagesTest(api_test.BaseTestCase):
+    def test_images(self):
+        res1 = self.client.images(all=True)
+        self.assertIn('Id', res1[0])
+        res10 = res1[0]
+        self.assertIn('Created', res10)
+        self.assertIn('RepoTags', res10)
+        distinct = []
+        for img in res1:
+            if img['Id'] not in distinct:
+                distinct.append(img['Id'])
+        self.assertEqual(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)
+
+
+class PullImageTest(api_test.BaseTestCase):
+    def test_pull(self):
+        try:
+            self.client.remove_image('hello-world')
+        except docker.errors.APIError:
+            pass
+        res = self.client.pull('hello-world')
+        self.tmp_imgs.append('hello-world')
+        self.assertEqual(type(res), six.text_type)
+        self.assertGreaterEqual(
+            len(self.client.images('hello-world')), 1
+        )
+        img_info = self.client.inspect_image('hello-world')
+        self.assertIn('Id', img_info)
+
+    def test_pull_streaming(self):
+        try:
+            self.client.remove_image('hello-world')
+        except docker.errors.APIError:
+            pass
+        stream = self.client.pull('hello-world', stream=True)
+        self.tmp_imgs.append('hello-world')
+        for chunk in stream:
+            if six.PY3:
+                chunk = chunk.decode('utf-8')
+            json.loads(chunk)  # ensure chunk is a single, valid JSON blob
+        self.assertGreaterEqual(
+            len(self.client.images('hello-world')), 1
+        )
+        img_info = self.client.inspect_image('hello-world')
+        self.assertIn('Id', img_info)
+
+
+class CommitTest(api_test.BaseTestCase):
+    def test_commit(self):
+        container = self.client.create_container(BUSYBOX, ['touch', '/test'])
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+        res = self.client.commit(id)
+        self.assertIn('Id', 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'])
+        busybox_id = self.client.inspect_image(BUSYBOX)['Id']
+        self.assertIn('Parent', img)
+        self.assertEqual(img['Parent'], busybox_id)
+
+
+class RemoveImageTest(api_test.BaseTestCase):
+    def test_remove(self):
+        container = self.client.create_container(BUSYBOX, ['touch', '/test'])
+        id = container['Id']
+        self.client.start(id)
+        self.tmp_containers.append(id)
+        res = self.client.commit(id)
+        self.assertIn('Id', res)
+        img_id = res['Id']
+        self.tmp_imgs.append(img_id)
+        self.client.remove_image(img_id, force=True)
+        images = self.client.images(all=True)
+        res = [x for x in images if x['Id'].startswith(img_id)]
+        self.assertEqual(len(res), 0)
+
+
+class ImportImageTest(api_test.BaseTestCase):
+    '''Base class for `docker import` test cases.'''
+
+    TAR_SIZE = 512 * 1024
+
+    def write_dummy_tar_content(self, n_bytes, tar_fd):
+        def extend_file(f, n_bytes):
+            f.seek(n_bytes - 1)
+            f.write(bytearray([65]))
+            f.seek(0)
+
+        tar = tarfile.TarFile(fileobj=tar_fd, mode='w')
+
+        with tempfile.NamedTemporaryFile() as f:
+            extend_file(f, n_bytes)
+            tarinfo = tar.gettarinfo(name=f.name, arcname='testdata')
+            tar.addfile(tarinfo, fileobj=f)
+
+        tar.close()
+
+    @contextlib.contextmanager
+    def dummy_tar_stream(self, n_bytes):
+        '''Yields a stream that is valid tar data of size n_bytes.'''
+        with tempfile.NamedTemporaryFile() as tar_file:
+            self.write_dummy_tar_content(n_bytes, tar_file)
+            tar_file.seek(0)
+            yield tar_file
+
+    @contextlib.contextmanager
+    def dummy_tar_file(self, n_bytes):
+        '''Yields the name of a valid tar file of size n_bytes.'''
+        with tempfile.NamedTemporaryFile() as tar_file:
+            self.write_dummy_tar_content(n_bytes, tar_file)
+            tar_file.seek(0)
+            yield tar_file.name
+
+    def test_import_from_bytes(self):
+        with self.dummy_tar_stream(n_bytes=500) as f:
+            content = f.read()
+
+        # The generic import_image() function cannot import in-memory bytes
+        # data that happens to be represented as a string type, because
+        # import_image() will try to use it as a filename and usually then
+        # trigger an exception. So we test the import_image_from_data()
+        # function instead.
+        statuses = self.client.import_image_from_data(
+            content, repository='test/import-from-bytes')
+
+        result_text = statuses.splitlines()[-1]
+        result = json.loads(result_text)
+
+        self.assertNotIn('error', result)
+
+        img_id = result['status']
+        self.tmp_imgs.append(img_id)
+
+    def test_import_from_file(self):
+        with self.dummy_tar_file(n_bytes=self.TAR_SIZE) as tar_filename:
+            # statuses = self.client.import_image(
+            #     src=tar_filename, repository='test/import-from-file')
+            statuses = self.client.import_image_from_file(
+                tar_filename, repository='test/import-from-file')
+
+        result_text = statuses.splitlines()[-1]
+        result = json.loads(result_text)
+
+        self.assertNotIn('error', result)
+
+        self.assertIn('status', result)
+        img_id = result['status']
+        self.tmp_imgs.append(img_id)
+
+    def test_import_from_stream(self):
+        with self.dummy_tar_stream(n_bytes=self.TAR_SIZE) as tar_stream:
+            statuses = self.client.import_image(
+                src=tar_stream, repository='test/import-from-stream')
+            # statuses = self.client.import_image_from_stream(
+            #     tar_stream, repository='test/import-from-stream')
+        result_text = statuses.splitlines()[-1]
+        result = json.loads(result_text)
+
+        self.assertNotIn('error', result)
+
+        self.assertIn('status', result)
+        img_id = result['status']
+        self.tmp_imgs.append(img_id)
+
+    @contextlib.contextmanager
+    def temporary_http_file_server(self, stream):
+        '''Serve data from an IO stream over HTTP.'''
+
+        class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header('Content-Type', 'application/x-tar')
+                self.end_headers()
+                shutil.copyfileobj(stream, self.wfile)
+
+        server = socketserver.TCPServer(('', 0), Handler)
+        thread = threading.Thread(target=server.serve_forever)
+        thread.setDaemon(True)
+        thread.start()
+
+        yield 'http://%s:%s' % (socket.gethostname(), server.server_address[1])
+
+        server.shutdown()
+
+    @pytest.mark.skipif(True, reason="Doesn't work inside a container - FIXME")
+    def test_import_from_url(self):
+        # The crappy test HTTP server doesn't handle large files well, so use
+        # a small file.
+        tar_size = 10240
+
+        with self.dummy_tar_stream(n_bytes=tar_size) as tar_data:
+            with self.temporary_http_file_server(tar_data) as url:
+                statuses = self.client.import_image(
+                    src=url, repository='test/import-from-url')
+
+        result_text = statuses.splitlines()[-1]
+        result = json.loads(result_text)
+
+        self.assertNotIn('error', result)
+
+        self.assertIn('status', result)
+        img_id = result['status']
+        self.tmp_imgs.append(img_id)

tests/integration/network_test.py

+import random
+
+import docker
+import pytest
+
+from . import api_test
+from ..base import requires_api_version
+
+
+@requires_api_version('1.21')
+class TestNetworks(api_test.BaseTestCase):
+    def create_network(self, *args, **kwargs):
+        net_name = 'dockerpy{}'.format(random.getrandbits(24))[:14]
+        net_id = self.client.create_network(net_name, *args, **kwargs)['id']
+        self.tmp_networks.append(net_id)
+        return (net_name, net_id)
+
+    def test_list_networks(self):
+        networks = self.client.networks()
+        initial_size = len(networks)
+
+        net_name, net_id = self.create_network()
+
+        networks = self.client.networks()
+        self.assertEqual(len(networks), initial_size + 1)
+        self.assertTrue(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])
+
+        networks_by_partial_id = self.client.networks(ids=[net_id[:8]])
+        self.assertEqual([n['id'] for n in networks_by_partial_id], [net_id])
+
+    def test_inspect_network(self):
+        net_name, net_id = self.create_network()
+
+        net = self.client.inspect_network(net_id)
+        self.assertEqual(net, {
+            u'name': net_name,
+            u'id': net_id,
+            u'driver': 'bridge',
+            u'containers': {},
+        })
+
+    def test_create_network_with_host_driver_fails(self):
+        net_name = 'dockerpy{}'.format(random.getrandbits(24))[:14]
+
+        with pytest.raises(docker.errors.APIError):
+            self.client.create_network(net_name, driver='host')
+
+    def test_remove_network(self):
+        initial_size = len(self.client.networks())
+
+        net_name, net_id = self.create_network()
+        self.assertEqual(len(self.client.networks()), initial_size + 1)
+
+        self.client.remove_network(net_id)
+        self.assertEqual(len(self.client.networks()), initial_size)
+
+    def test_connect_and_disconnect_container(self):
+        net_name, net_id = self.create_network()
+
+        container = self.client.create_container('busybox', 'top')
+        self.tmp_containers.append(container)
+        self.client.start(container)
+
+        network_data = self.client.inspect_network(net_id)
+        self.assertFalse(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']])
+
+        self.client.disconnect_container_from_network(container, net_id)
+        network_data = self.client.inspect_network(net_id)
+        self.assertFalse(network_data.get('containers'))
+
+    def test_connect_on_container_create(self):
+        net_name, net_id = self.create_network()
+
+        container = self.client.create_container(
+            image='busybox',
+            command='top',
+            host_config=self.client.create_host_config(network_mode=net_name),
+        )
+        self.tmp_containers.append(container)
+        self.client.start(container)
+
+        network_data = self.client.inspect_network(net_id)
+        self.assertEqual(
+            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'))

tests/integration/regression_test.py

+import io
+import random
+
+import docker
+import six
+
+from . import api_test
+
+BUSYBOX = api_test.BUSYBOX
+
+
+class TestRegressions(api_test.BaseTestCase):
+    def test_443_handle_nonchunked_response_in_stream(self):
+        dfile = io.BytesIO()
+        with self.assertRaises(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)
+        dfile.close()
+
+    def test_542_truncate_ids_client_side(self):
+        self.client.start(
+            self.client.create_container(BUSYBOX, ['true'])
+        )
+        result = self.client.containers(all=True, trunc=True)
+        self.assertEqual(len(result[0]['Id']), 12)
+
+    def test_647_support_doubleslash_in_image_names(self):
+        with self.assertRaises(docker.errors.APIError):
+            self.client.inspect_image('gensokyo.jp//kirisame')
+
+    def test_649_handle_timeout_value_none(self):
+        self.client.timeout = None
+        ctnr = self.client.create_container(BUSYBOX, ['sleep', '2'])
+        self.client.start(ctnr)
+        self.client.stop(ctnr)
+
+    def test_715_handle_user_param_as_int_value(self):
+        ctnr = self.client.create_container(BUSYBOX, ['id', '-u'], user=1000)
+        self.client.start(ctnr)
+        self.client.wait(ctnr)
+        logs = self.client.logs(ctnr)
+        if six.PY3:
+            logs = logs.decode('utf-8')
+        assert logs == '1000\n'
+
+    def test_792_explicit_port_protocol(self):
+
+        tcp_port, udp_port = random.sample(range(9999, 32000), 2)
+        ctnr = self.client.create_container(
+            BUSYBOX, ['sleep', '9999'], ports=[2000, (2000, 'udp')],
+            host_config=self.client.create_host_config(
+                port_bindings={'2000/tcp': tcp_port, '2000/udp': udp_port}
+            )
+        )
+        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)
+        )

tests/integration/volume_test.py

+import docker
+import pytest
+
+from . import api_test
+from ..base import requires_api_version
+
+
+@requires_api_version('1.21')
+class TestVolumes(api_test.BaseTestCase):
+    def test_create_volume(self):
+        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')
+
+    def test_create_volume_invalid_driver(self):
+        driver_name = 'invalid.driver'
+
+        with pytest.raises(docker.errors.NotFound):
+            self.client.create_volume('perfectcherryblossom', driver_name)
+
+    def test_list_volumes(self):
+        name = 'imperishablenight'
+        self.tmp_volumes.append(name)
+        volume_info = self.client.create_volume(name)
+        result = self.client.volumes()
+        self.assertIn('Volumes', result)
+        volumes = result['Volumes']
+        self.assertIn(volume_info, 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)
+
+    def test_inspect_nonexistent_volume(self):
+        name = 'embodimentofscarletdevil'
+        with pytest.raises(docker.errors.NotFound):
+            self.client.inspect_volume(name)
+
+    def test_remove_volume(self):
+        name = 'shootthebullet'
+        self.tmp_volumes.append(name)
+        self.client.create_volume(name)
+        result = self.client.remove_volume(name)
+        self.assertTrue(result)
+
+    def test_remove_nonexistent_volume(self):
+        name = 'shootthebullet'
+        with pytest.raises(docker.errors.NotFound):
+            self.client.remove_volume(name)

tests/unit/auth_test.py

+# -*- coding: utf-8 -*-
+
+import base64
+import json
+import os
+import os.path
+import random
+import shutil
+import tempfile
+
+from docker import auth
+
+from .. import base
+
+try:
+    from unittest import mock
+except ImportError:
+    import mock
+
+
+class RegressionTest(base.BaseTestCase):
+    def test_803_urlsafe_encode(self):
+        auth_data = {
+            'username': 'root',
+            'password': 'GR?XGR?XGR?XGR?X'
+        }
+        encoded = auth.encode_header(auth_data)
+        assert b'/' not in encoded
+        assert b'_' in encoded
+
+
+class ResolveAuthTest(base.BaseTestCase):
+    auth_config = {
+        'https://index.docker.io/v1/': {'auth': 'indexuser'},
+        'my.registry.net': {'auth': 'privateuser'},
+        'http://legacy.registry.url/v1/': {'auth': 'legacyauth'}
+    }
+
+    def test_resolve_repository_name_hub_library_image(self):
+        self.assertEqual(
+            auth.resolve_repository_name('image'),
+            ('index.docker.io', 'image'),
+        )
+
+    def test_resolve_repository_name_hub_image(self):
+        self.assertEqual(
+            auth.resolve_repository_name('username/image'),
+            ('index.docker.io', 'username/image'),
+        )
+
+    def test_resolve_repository_name_private_registry(self):
+        self.assertEqual(
+            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'),
+        )
+
+    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'),
+        )
+
+    def test_resolve_repository_name_no_dots_but_port(self):
+        self.assertEqual(
+            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'),
+        )
+
+    def test_resolve_repository_name_localhost(self):
+        self.assertEqual(
+            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'),
+        )
+
+    def test_resolve_authconfig_hostname_only(self):
+        self.assertEqual(
+            auth.resolve_authconfig(self.auth_config, 'my.registry.net'),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_no_protocol(self):
+        self.assertEqual(
+            auth.resolve_authconfig(self.auth_config, 'my.registry.net/v1/'),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_no_path(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'http://my.registry.net'
+            ),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_no_path_trailing_slash(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'http://my.registry.net/'
+            ),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_no_path_wrong_secure_proto(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'https://my.registry.net'
+            ),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_no_path_wrong_insecure_proto(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'http://index.docker.io'
+            ),
+            {'auth': 'indexuser'}
+        )
+
+    def test_resolve_authconfig_path_wrong_proto(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'https://my.registry.net/v1/'
+            ),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_default_registry(self):
+        self.assertEqual(
+            auth.resolve_authconfig(self.auth_config), {'auth': 'indexuser'}
+        )
+
+    def test_resolve_authconfig_default_explicit_none(self):
+        self.assertEqual(
+            auth.resolve_authconfig(self.auth_config, None),
+            {'auth': 'indexuser'}
+        )
+
+    def test_resolve_authconfig_fully_explicit(self):
+        self.assertEqual(
+            auth.resolve_authconfig(
+                self.auth_config, 'http://my.registry.net/v1/'
+            ),
+            {'auth': 'privateuser'}
+        )
+
+    def test_resolve_authconfig_legacy_config(self):
+        self.assertEqual(
+            auth.resolve_authconfig(self.auth_config, 'legacy.registry.url'),
+            {'auth': 'legacyauth'}
+        )
+
+    def test_resolve_authconfig_no_match(self):
+        self.assertTrue(
+            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]
+            ),
+            {'auth': '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]
+            ),
+            {'auth': '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]
+            ),
+            {'auth': '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,
+        )
+
+
+class LoadConfigTest(base.Cleanup, base.BaseTestCase):
+    def test_load_config_no_file(self):
+        folder = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, folder)
+        cfg = auth.load_config(folder)
+        self.assertTrue(cfg is not None)
+
+    def test_load_config(self):
+        folder = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, folder)
+        dockercfg_path = os.path.join(folder, '.dockercfg')
+        with open(dockercfg_path, 'w') as f:
+            auth_ = base64.b64encode(b'sakuya:izayoi').decode('ascii')
+            f.write('auth = {0}\n'.format(auth_))
+            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)
+        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)
+
+    def test_load_config_with_random_name(self):
+        folder = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, folder)
+
+        dockercfg_path = os.path.join(folder,
+                                      '.{0}.dockercfg'.format(
+                                          random.randrange(100000)))
+        registry = 'https://your.private.registry.io'
+        auth_ = base64.b64encode(b'sakuya:izayoi').decode('ascii')
+        config = {
+            registry: {
+                'auth': '{0}'.format(auth_),
+                'email': 'sakuya@scarlet.net'
+            }
+        }
+
+        with open(dockercfg_path, 'w') as f:
+            json.dump(config, f)
+
+        cfg = auth.load_config(dockercfg_path)
+        assert registry in cfg
+        self.assertNotEqual(cfg[registry], 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)
+
+    def test_load_config_custom_config_env(self):
+        folder = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, folder)
+
+        dockercfg_path = os.path.join(folder, 'config.json')
+        registry = 'https://your.private.registry.io'
+        auth_ = base64.b64encode(b'sakuya:izayoi').decode('ascii')
+        config = {
+            registry: {
+                'auth': '{0}'.format(auth_),
+                'email': 'sakuya@scarlet.net'
+            }
+        }
+
+        with open(dockercfg_path, 'w') as f:
+            json.dump(config, f)
+
+        with mock.patch.dict(os.environ, {'DOCKER_CONFIG': folder}):
+            cfg = auth.load_config(None)
+            assert registry in cfg
+            self.assertNotEqual(cfg[registry], 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)

tests/unit/build_test.py

+import gzip
+import io
+
+import docker
+
+from .api_test import DockerClientTest
+
+
+class BuildTest(DockerClientTest):
+    def test_build_container(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+
+        self.client.build(fileobj=script)
+
+    def test_build_container_pull(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+
+        self.client.build(fileobj=script, pull=True)
+
+    def test_build_container_stream(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+
+        self.client.build(fileobj=script, stream=True)
+
+    def test_build_container_custom_context(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+        context = docker.utils.mkbuildcontext(script)
+
+        self.client.build(fileobj=context, custom_context=True)
+
+    def test_build_container_custom_context_gzip(self):
+        script = io.BytesIO('\n'.join([
+            'FROM busybox',
+            'MAINTAINER docker-py',
+            'RUN mkdir -p /tmp/test',
+            'EXPOSE 8080',
+            'ADD https://dl.dropboxusercontent.com/u/20637798/silence.tar.gz'
+            ' /tmp/silence.tar.gz'
+        ]).encode('ascii'))
+        context = docker.utils.mkbuildcontext(script)
+        gz_context = gzip.GzipFile(fileobj=context)
+
+        self.client.build(
+            fileobj=gz_context,
+            custom_context=True,
+            encoding="gzip"
+        )
+
+    def test_build_remote_with_registry_auth(self):
+        self.client._auth_configs = {
+            'https://example.com': {
+                'user': 'example',
+                'password': 'example',
+                'email': 'example@example.com'
+            }
+        }
+
+        self.client.build(path='https://github.com/docker-library/mongo')
+
+    def test_build_container_with_named_dockerfile(self):
+        self.client.build('.', dockerfile='nameddockerfile')
+
+    def test_build_container_with_container_limits(self):
+        self.client.build('.', container_limits={
+            'memory': 1024 * 1024,
+            'cpusetcpus': 1,
+            'cpushares': 1000,
+            'memswap': 1024 * 1024 * 8
+        })
+
+    def test_build_container_invalid_container_limits(self):
+        self.assertRaises(
+            docker.errors.DockerException,
+            lambda: self.client.build('.', container_limits={
+                'foo': 'bar'
+            })
+        )

tests/unit/exec_test.py

+import json
+
+from . import fake_api
+from .api_test import (
+    DockerClientTest, url_prefix, fake_request, DEFAULT_TIMEOUT_SECONDS,
+)
+
+
+class ExecTest(DockerClientTest):
+    def test_exec_create(self):
+        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
+            )
+        )
+
+        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': ''
+            }
+        )
+
+        self.assertEqual(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
+            )
+        )
+
+        self.assertEqual(
+            json.loads(args[1]['data']), {
+                'Tty': False,
+                'Detach': False,
+            }
+        )
+
+        self.assertEqual(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
+            )
+        )
+
+    def test_exec_resize(self):
+        self.client.exec_resize(fake_api.FAKE_EXEC_ID, height=20, width=60)
+
+        fake_request.assert_called_with(
+            'POST',
+            url_prefix + 'exec/{0}/resize'.format(fake_api.FAKE_EXEC_ID),
+            params={'h': 20, 'w': 60},
+            timeout=DEFAULT_TIMEOUT_SECONDS
+        )

tox.ini

@@ -5,7 +5,7 @@ skipsdist=True
 [testenv]
 usedevelop=True
 commands =
-    py.test --cov=docker tests/test.py tests/utils_test.py
+    py.test --cov=docker tests/unit/
 deps =
     -r{toxinidir}/test-requirements.txt
     -r{toxinidir}/requirements.txt