Updated unit tests

* Warnings will now raise exceptions in unit tests
* Updated several tests to use host_config

1 files changed, 221 insertions, 204 deletions

diff --git a/tests/test.py b/tests/test.py
index e4f658d..b806ae9 100644
--- a/tests/test.py
+++ b/tests/test.py
@@ -14,6 +14,7 @@
 
 import base64
 import datetime
+import gzip
 import io
 import json
 import os
@@ -23,7 +24,7 @@ import sys
 import tarfile
 import tempfile
 import unittest
-import gzip
+import warnings
 
 import docker
 import requests
@@ -31,13 +32,16 @@ import six
 
 import fake_api
 
-
 try:
     from unittest import mock
 except ImportError:
     import mock
 
 
+warnings.simplefilter('error')
+create_host_config = docker.utils.create_host_config
+
+
 def response(status_code=200, content='', headers=None, reason=None, elapsed=0,
              request=None):
     res = requests.Response()
@@ -102,6 +106,17 @@ class DockerClientTest(Cleanup, unittest.TestCase):
     def tearDown(self):
         self.client.close()
 
+    def base_create_payload(self, img='busybox', cmd=None):
+        if not cmd:
+            cmd = ['true']
+        return {"Tty": False, "Image": img, "Cmd": cmd,
+                "AttachStdin": False, "Memory": 0,
+                "AttachStderr": True, "AttachStdout": True,
+                "StdinOnce": False,
+                "OpenStdin": False, "NetworkDisabled": False,
+                "MemorySwap": 0
+                }
+
     def test_ctor(self):
         try:
             docker.Client(version=1.12)
@@ -109,7 +124,7 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             self.assertTrue(isinstance(e, docker.errors.DockerException))
             if not six.PY3:
                 self.assertEqual(
-                    e.message,
+                    str(e),
                     'version parameter must be a string. Found float'
                 )
 
@@ -583,24 +598,27 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_lxc_conf(self):
+    def test_create_container_with_lxc_conf(self):
         try:
-            self.client.start(
-                fake_api.FAKE_CONTAINER_ID,
-                lxc_conf={'lxc.conf.k': 'lxc.conf.value'}
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    lxc_conf={'lxc.conf.k': 'lxc.conf.value'}
+                )
             )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
         args = fake_request.call_args
         self.assertEqual(
             args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"LxcConf": [{"Value": "lxc.conf.value", "Key": "lxc.conf.k"}],
-             "PublishAllPorts": False, "Privileged": False}
+            url_prefix + 'containers/create'
         )
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['LxcConf'] = [
+            {"Value": "lxc.conf.value", "Key": "lxc.conf.k"}
+        ]
+
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
             args[1]['headers'],
             {'Content-Type': 'application/json'}
@@ -610,26 +628,25 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_lxc_conf_compat(self):
+    def test_create_container_with_lxc_conf_compat(self):
         try:
-            self.client.start(
-                fake_api.FAKE_CONTAINER_ID,
-                lxc_conf=[{'Key': 'lxc.conf.k', 'Value': 'lxc.conf.value'}]
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    lxc_conf=[{'Key': 'lxc.conf.k', 'Value': 'lxc.conf.value'}]
+                )
             )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
-        self.assertEqual(args[0][0], url_prefix +
-                         'containers/3cc2351ab11b/start')
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['LxcConf'] = [
+            {"Value": "lxc.conf.value", "Key": "lxc.conf.k"}
+        ]
         self.assertEqual(
-            json.loads(args[1]['data']),
-            {
-                "LxcConf": [{"Key": "lxc.conf.k", "Value": "lxc.conf.value"}],
-                "PublishAllPorts": False,
-                "Privileged": False,
-            }
-        )
+            json.loads(args[1]['data']), expected_payload)
         self.assertEqual(args[1]['headers'],
                          {'Content-Type': 'application/json'})
         self.assertEqual(
@@ -637,48 +654,57 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_binds_ro(self):
+    def test_create_container_with_binds_ro(self):
         try:
             mount_dest = '/mnt'
             mount_origin = '/tmp'
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              binds={mount_origin: {
-                                  "bind": mount_dest,
-                                  "ro": True
-                              }})
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    binds={mount_origin: {
+                        "bind": mount_dest,
+                        "ro": True
+                    }}
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
         self.assertEqual(args[0][0], url_prefix +
-                         'containers/3cc2351ab11b/start')
-        self.assertEqual(json.loads(args[1]['data']),
-                         {"Binds": ["/tmp:/mnt:ro"],
-                          "PublishAllPorts": False,
-                          "Privileged": False})
+                         'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Binds'] = ["/tmp:/mnt:ro"]
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(args[1]['headers'],
                          {'Content-Type': 'application/json'})
         self.assertEqual(
             args[1]['timeout'],
-            docker.client.DEFAULT_TIMEOUT_SECONDS)
+            docker.client.DEFAULT_TIMEOUT_SECONDS
+        )
 
-    def test_start_container_with_binds_rw(self):
+    def test_create_container_with_binds_rw(self):
         try:
             mount_dest = '/mnt'
             mount_origin = '/tmp'
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              binds={mount_origin: {
-                                  "bind": mount_dest, "ro": False}})
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    binds={mount_origin: {
+                        "bind": mount_dest,
+                        "ro": False
+                    }}
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
         self.assertEqual(args[0][0], url_prefix +
-                         'containers/3cc2351ab11b/start')
-        self.assertEqual(json.loads(args[1]['data']),
-                         {"Binds": ["/tmp:/mnt:rw"],
-                          "PublishAllPorts": False,
-                          "Privileged": False})
+                         'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Binds'] = ["/tmp:/mnt:rw"]
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(args[1]['headers'],
                          {'Content-Type': 'application/json'})
         self.assertEqual(
@@ -689,49 +715,53 @@ class DockerClientTest(Cleanup, unittest.TestCase):
     def test_start_container_with_port_binds(self):
         self.maxDiff = None
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID, port_bindings={
-                1111: None,
-                2222: 2222,
-                '3333/udp': (3333,),
-                4444: ('127.0.0.1',),
-                5555: ('127.0.0.1', 5555),
-                6666: [('127.0.0.1',), ('192.168.0.1',)]
-            })
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    port_bindings={
+                        1111: None,
+                        2222: 2222,
+                        '3333/udp': (3333,),
+                        4444: ('127.0.0.1',),
+                        5555: ('127.0.0.1', 5555),
+                        6666: [('127.0.0.1',), ('192.168.0.1',)]
+                    }
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
-        self.assertEqual(args[0][0], url_prefix +
-                         'containers/3cc2351ab11b/start')
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
         data = json.loads(args[1]['data'])
-        self.assertEqual(data['PublishAllPorts'], False)
-        self.assertTrue('1111/tcp' in data['PortBindings'])
-        self.assertTrue('2222/tcp' in data['PortBindings'])
-        self.assertTrue('3333/udp' in data['PortBindings'])
-        self.assertTrue('4444/tcp' in data['PortBindings'])
-        self.assertTrue('5555/tcp' in data['PortBindings'])
-        self.assertTrue('6666/tcp' in data['PortBindings'])
+        self.assertEqual(data['HostConfig']['PublishAllPorts'], False)
+        port_bindings = data['HostConfig']['PortBindings']
+        self.assertTrue('1111/tcp' in port_bindings)
+        self.assertTrue('2222/tcp' in port_bindings)
+        self.assertTrue('3333/udp' in port_bindings)
+        self.assertTrue('4444/tcp' in port_bindings)
+        self.assertTrue('5555/tcp' in port_bindings)
+        self.assertTrue('6666/tcp' in port_bindings)
         self.assertEqual(
             [{"HostPort": "", "HostIp": ""}],
-            data['PortBindings']['1111/tcp']
+            port_bindings['1111/tcp']
         )
         self.assertEqual(
             [{"HostPort": "2222", "HostIp": ""}],
-            data['PortBindings']['2222/tcp']
+            port_bindings['2222/tcp']
         )
         self.assertEqual(
             [{"HostPort": "3333", "HostIp": ""}],
-            data['PortBindings']['3333/udp']
+            port_bindings['3333/udp']
         )
         self.assertEqual(
             [{"HostPort": "", "HostIp": "127.0.0.1"}],
-            data['PortBindings']['4444/tcp']
+            port_bindings['4444/tcp']
         )
         self.assertEqual(
             [{"HostPort": "5555", "HostIp": "127.0.0.1"}],
-            data['PortBindings']['5555/tcp']
+            port_bindings['5555/tcp']
         )
-        self.assertEqual(len(data['PortBindings']['6666/tcp']), 2)
+        self.assertEqual(len(port_bindings['6666/tcp']), 2)
         self.assertEqual(args[1]['headers'],
                          {'Content-Type': 'application/json'})
         self.assertEqual(
@@ -739,101 +769,96 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_links(self):
-        # one link
+    def test_create_container_with_links(self):
         try:
             link_path = 'path'
             alias = 'alias'
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              links={link_path: alias})
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    links={link_path: alias}
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "Links": ["path:alias"]}
+            args[0][0], url_prefix + 'containers/create'
         )
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Links'] = ['path:alias']
+
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
 
-    def test_start_container_with_multiple_links(self):
+    def test_create_container_with_multiple_links(self):
         try:
             link_path = 'path'
             alias = 'alias'
-            self.client.start(
-                fake_api.FAKE_CONTAINER_ID,
-                links={
-                    link_path + '1': alias + '1',
-                    link_path + '2': alias + '2'
-                }
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    links={
+                        link_path + '1': alias + '1',
+                        link_path + '2': alias + '2'
+                    }
+                )
             )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Links'] = [
+            'path1:alias1', 'path2:alias2'
+        ]
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {
-                "PublishAllPorts": False,
-                "Privileged": False,
-                "Links": ["path1:alias1", "path2:alias2"]
-            }
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
 
-    def test_start_container_with_links_as_list_of_tuples(self):
-        # one link
+    def test_create_container_with_links_as_list_of_tuples(self):
         try:
             link_path = 'path'
             alias = 'alias'
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              links=[(link_path, alias)])
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    links=[(link_path, alias)]
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Links'] = ['path:alias']
+
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "Links": ["path:alias"]}
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
 
-    def test_start_container_privileged(self):
+    def test_create_container_privileged(self):
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID, privileged=True)
+            self.client.create_container(
+                'busybox', 'true',
+                host_config=create_host_config(privileged=True)
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
 
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Privileged'] = True
         args = fake_request.call_args
-        self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(json.loads(args[1]['data']),
-                         {"PublishAllPorts": False, "Privileged": True})
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(args[1]['headers'],
                          {'Content-Type': 'application/json'})
         self.assertEqual(
@@ -864,117 +889,109 @@ class DockerClientTest(Cleanup, unittest.TestCase):
             docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_restart_policy(self):
+    def test_create_container_with_restart_policy(self):
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              restart_policy={
-                                  "Name": "always",
-                                  "MaximumRetryCount": 0
-                              })
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    restart_policy={
+                        "Name": "always",
+                        "MaximumRetryCount": 0
+                    }
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['RestartPolicy'] = {
+            "MaximumRetryCount": 0, "Name": "always"
+        }
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
+
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "RestartPolicy": {"MaximumRetryCount": 0, "Name": "always"}}
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
         self.assertEqual(
-            args[1]['timeout'],
-            docker.client.DEFAULT_TIMEOUT_SECONDS
+            args[1]['timeout'], docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_added_capabilities(self):
+    def test_create_container_with_added_capabilities(self):
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              cap_add=['MKNOD'])
+            self.client.create_container(
+                'busybox', 'true',
+                host_config=create_host_config(cap_add=['MKNOD'])
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['CapAdd'] = ['MKNOD']
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "CapAdd": ["MKNOD"]}
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
         self.assertEqual(
-            args[1]['timeout'],
-            docker.client.DEFAULT_TIMEOUT_SECONDS
+            args[1]['timeout'], docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_dropped_capabilities(self):
+    def test_create_container_with_dropped_capabilities(self):
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              cap_drop=['MKNOD'])
+            self.client.create_container(
+                'busybox', 'true',
+                host_config=create_host_config(cap_drop=['MKNOD'])
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['CapDrop'] = ['MKNOD']
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "CapDrop": ["MKNOD"]}
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
         self.assertEqual(
-            args[1]['timeout'],
-            docker.client.DEFAULT_TIMEOUT_SECONDS
+            args[1]['timeout'], docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
-    def test_start_container_with_devices(self):
+    def test_create_container_with_devices(self):
         try:
-            self.client.start(fake_api.FAKE_CONTAINER_ID,
-                              devices=['/dev/sda:/dev/xvda:rwm',
-                                       '/dev/sdb:/dev/xvdb',
-                                       '/dev/sdc'])
+            self.client.create_container(
+                'busybox', 'true', host_config=create_host_config(
+                    devices=['/dev/sda:/dev/xvda:rwm',
+                             '/dev/sdb:/dev/xvdb',
+                             '/dev/sdc']
+                )
+            )
         except Exception as e:
             self.fail('Command should not raise exception: {0}'.format(e))
         args = fake_request.call_args
+        self.assertEqual(args[0][0], url_prefix + 'containers/create')
+        expected_payload = self.base_create_payload()
+        expected_payload['HostConfig'] = create_host_config()
+        expected_payload['HostConfig']['Devices'] = [
+            {'CgroupPermissions': 'rwm',
+             'PathInContainer': '/dev/xvda',
+             'PathOnHost': '/dev/sda'},
+            {'CgroupPermissions': 'rwm',
+             'PathInContainer': '/dev/xvdb',
+             'PathOnHost': '/dev/sdb'},
+            {'CgroupPermissions': 'rwm',
+             'PathInContainer': '/dev/sdc',
+             'PathOnHost': '/dev/sdc'}
+        ]
+        self.assertEqual(json.loads(args[1]['data']), expected_payload)
         self.assertEqual(
-            args[0][0],
-            url_prefix + 'containers/3cc2351ab11b/start'
-        )
-        self.assertEqual(
-            json.loads(args[1]['data']),
-            {"PublishAllPorts": False, "Privileged": False,
-             "Devices": [{'CgroupPermissions': 'rwm',
-                          'PathInContainer': '/dev/xvda',
-                          'PathOnHost': '/dev/sda'},
-                         {'CgroupPermissions': 'rwm',
-                          'PathInContainer': '/dev/xvdb',
-                          'PathOnHost': '/dev/sdb'},
-                         {'CgroupPermissions': 'rwm',
-                          'PathInContainer': '/dev/sdc',
-                          'PathOnHost': '/dev/sdc'}]}
-        )
-        self.assertEqual(
-            args[1]['headers'],
-            {'Content-Type': 'application/json'}
+            args[1]['headers'], {'Content-Type': 'application/json'}
         )
         self.assertEqual(
-            args[1]['timeout'],
-            docker.client.DEFAULT_TIMEOUT_SECONDS
+            args[1]['timeout'], docker.client.DEFAULT_TIMEOUT_SECONDS
         )
 
     def test_resize_container(self):