# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import copy
from unittest import mock


from senlin.common import context
from senlin.common import exception as exc
from senlin.common.i18n import _
from senlin.db.sqlalchemy import api as db_api
from senlin.engine import cluster
from senlin.engine import node
from senlin.objects import cluster as co
from senlin.objects import node as no
from senlin.profiles import base as pb
from senlin.profiles.container import docker as dp
from senlin.tests.unit.common import base
from senlin.tests.unit.common import utils


class TestContainerDockerProfile(base.SenlinTestCase):

    def setUp(self):
        super(TestContainerDockerProfile, self).setUp()

        self.context = utils.dummy_context()
        self.spec = {
            'type': 'container.dockerinc.docker',
            'version': '1.0',
            'properties': {
                'context': {
                    'region_name': 'RegionOne'
                },
                'name': 'docker_container',
                'image': 'hello-world',
                'command': '/bin/sleep 30',
                'port': 2375,
                'host_node': 'fake_node',
            }
        }

    def test_init(self):
        profile = dp.DockerProfile('t', self.spec)
        self.assertIsNone(profile._dockerclient)
        self.assertIsNone(profile.container_id)
        self.assertIsNone(profile.host)

    @mock.patch.object(dp.DockerProfile, 'do_validate')
    @mock.patch.object(db_api, 'node_add_dependents')
    @mock.patch.object(db_api, 'cluster_add_dependents')
    def test_create_with_host_node(self, mock_cadd, mock_nadd, mock_validate):
        mock_validate.return_value = None

        profile = dp.DockerProfile.create(
            self.context, 'fake_name', self.spec)

        self.assertIsNotNone(profile)
        mock_nadd.assert_called_once_with(self.context, 'fake_node',
                                          profile.id, 'profile')
        self.assertEqual(0, mock_cadd.call_count)

    @mock.patch.object(dp.DockerProfile, 'do_validate')
    @mock.patch.object(db_api, 'node_add_dependents')
    @mock.patch.object(db_api, 'cluster_add_dependents')
    def test_create_with_host_cluster(self, mock_cadd, mock_nadd,
                                      mock_validate):
        mock_validate.return_value = None
        spec = copy.deepcopy(self.spec)
        del spec['properties']['host_node']
        spec['properties']['host_cluster'] = 'fake_cluster'

        profile = dp.DockerProfile.create(
            self.context, 'fake_name', spec)

        self.assertIsNotNone(profile)
        mock_cadd.assert_called_once_with(self.context, 'fake_cluster',
                                          profile.id)
        self.assertEqual(0, mock_nadd.call_count)

    @mock.patch.object(pb.Profile, 'delete')
    @mock.patch.object(pb.Profile, 'load')
    @mock.patch.object(db_api, 'node_remove_dependents')
    @mock.patch.object(db_api, 'cluster_remove_dependents')
    def test_delete_with_host_node(self, mock_cdel, mock_ndel, mock_load,
                                   mock_delete):
        profile = dp.DockerProfile('t', self.spec)
        mock_load.return_value = profile

        res = dp.DockerProfile.delete(self.context, 'FAKE_ID')

        self.assertIsNone(res)
        mock_load.assert_called_once_with(self.context, profile_id='FAKE_ID')
        mock_ndel.assert_called_once_with(self.context, 'fake_node',
                                          'FAKE_ID', 'profile')
        self.assertEqual(0, mock_cdel.call_count)
        mock_delete.assert_called_once_with(self.context, 'FAKE_ID')

    @mock.patch.object(pb.Profile, 'delete')
    @mock.patch.object(pb.Profile, 'load')
    @mock.patch.object(db_api, 'node_remove_dependents')
    @mock.patch.object(db_api, 'cluster_remove_dependents')
    def test_delete_with_host_cluster(self, mock_cdel, mock_ndel, mock_load,
                                      mock_delete):
        spec = copy.deepcopy(self.spec)
        del spec['properties']['host_node']
        spec['properties']['host_cluster'] = 'fake_cluster'
        profile = dp.DockerProfile('fake_name', spec)
        mock_load.return_value = profile

        res = dp.DockerProfile.delete(self.context, 'FAKE_ID')

        self.assertIsNone(res)
        mock_load.assert_called_once_with(self.context, profile_id='FAKE_ID')
        mock_cdel.assert_called_once_with(self.context, 'fake_cluster',
                                          'FAKE_ID')
        self.assertEqual(0, mock_ndel.call_count)

    @mock.patch('senlin.drivers.container.docker_v1.DockerClient')
    @mock.patch.object(dp.DockerProfile, '_get_host_ip')
    @mock.patch.object(dp.DockerProfile, '_get_host')
    @mock.patch.object(context, 'get_admin_context')
    def test_docker_client(self, mock_ctx, mock_host, mock_ip, mock_client):
        ctx = mock.Mock()
        mock_ctx.return_value = ctx
        profile = mock.Mock(type_name='os.nova.server')
        host = mock.Mock(rt={'profile': profile}, physical_id='server1')
        mock_host.return_value = host
        fake_ip = '1.2.3.4'
        mock_ip.return_value = fake_ip
        dockerclient = mock.Mock()
        mock_client.return_value = dockerclient
        profile = dp.DockerProfile('container', self.spec)
        obj = mock.Mock()
        client = profile.docker(obj)
        self.assertEqual(dockerclient, client)
        mock_host.assert_called_once_with(ctx, 'fake_node', None)
        mock_ip.assert_called_once_with(obj, 'server1', 'os.nova.server')
        url = 'tcp://1.2.3.4:2375'
        mock_client.assert_called_once_with(url)

    @mock.patch.object(dp.DockerProfile, '_get_host')
    def test_docker_client_wrong_host_type(self, mock_get):
        profile = mock.Mock(type_name='wrong_type')
        host = mock.Mock(rt={'profile': profile}, physical_id='server1')
        mock_get.return_value = host
        obj = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)
        ex = self.assertRaises(exc.InternalError,
                               profile.docker, obj)
        msg = _('Type of host node (wrong_type) is not supported')

        self.assertEqual(msg, ex.message)

    @mock.patch.object(dp.DockerProfile, '_get_host_ip')
    @mock.patch.object(dp.DockerProfile, '_get_host')
    def test_docker_client_get_host_ip_failed(self, mock_host, mock_ip):
        profile = mock.Mock(type_name='os.nova.server')
        host = mock.Mock(rt={'profile': profile}, physical_id='server1')
        mock_host.return_value = host
        mock_ip.return_value = None
        obj = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)
        ex = self.assertRaises(exc.InternalError,
                               profile.docker, obj)
        msg = _('Unable to determine the IP address of host node')

        self.assertEqual(msg, ex.message)

    @mock.patch.object(node.Node, 'load')
    def test_get_host_node_found_by_node(self, mock_load):
        node = mock.Mock()
        mock_load.return_value = node
        ctx = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)

        res = profile._get_host(ctx, 'host_node', None)

        self.assertEqual(node, res)
        mock_load.assert_called_once_with(ctx, node_id='host_node')

    @mock.patch.object(dp.DockerProfile, '_get_random_node')
    def test_get_host_node_found_by_cluster(self, mock_get):
        node = mock.Mock()
        mock_get.return_value = node
        ctx = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)

        res = profile._get_host(ctx, None, 'host_cluster')

        self.assertEqual(node, res)
        mock_get.assert_called_once_with(ctx, 'host_cluster')

    @mock.patch.object(node.Node, 'load')
    def test_get_host_node_not_found(self, mock_load):
        mock_load.side_effect = exc.ResourceNotFound(type='node',
                                                     id='fake_node')
        profile = dp.DockerProfile('container', self.spec)
        ctx = mock.Mock()

        ex = self.assertRaises(exc.InternalError,
                               profile._get_host,
                               ctx, 'fake_node', None)

        msg = _("The host node 'fake_node' could not be found.")
        self.assertEqual(msg, ex.message)

    @mock.patch.object(node.Node, 'load')
    @mock.patch.object(no.Node, 'get_all_by_cluster')
    @mock.patch.object(cluster.Cluster, 'load')
    def test_get_random_node(self, mock_cluster, mock_nodes, mock_load):
        cluster = mock.Mock()
        mock_cluster.return_value = cluster
        node1 = mock.Mock()
        node2 = mock.Mock()
        mock_nodes.return_value = [node1, node2]
        profile = dp.DockerProfile('container', self.spec)
        ctx = mock.Mock()
        x_node = mock.Mock()
        mock_load.return_value = x_node

        res = profile._get_random_node(ctx, 'host_cluster')

        self.assertEqual(x_node, res)
        mock_cluster.assert_called_once_with(ctx, cluster_id='host_cluster')
        mock_nodes.assert_called_once_with(ctx, cluster_id='host_cluster',
                                           filters={'status': 'ACTIVE'})
        mock_load.assert_called_once_with(ctx, db_node=mock.ANY)
        n = mock_load.call_args[1]['db_node']
        self.assertIn(n, [node1, node2])

    @mock.patch.object(cluster.Cluster, 'load')
    def test_get_random_node_cluster_not_found(self, mock_load):
        mock_load.side_effect = exc.ResourceNotFound(type='cluster',
                                                     id='host_cluster')
        ctx = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.InternalError,
                               profile._get_random_node,
                               ctx, 'host_cluster')

        msg = _("The host cluster 'host_cluster' could not be found.")
        self.assertEqual(msg, ex.message)

    @mock.patch.object(no.Node, 'get_all_by_cluster')
    @mock.patch.object(cluster.Cluster, 'load')
    def test_get_random_node_empty_cluster(self, mock_cluster, mock_nodes):
        cluster = mock.Mock()
        mock_cluster.return_value = cluster
        mock_nodes.return_value = []
        profile = dp.DockerProfile('container', self.spec)
        ctx = mock.Mock()

        ex = self.assertRaises(exc.InternalError,
                               profile._get_random_node,
                               ctx, 'host_cluster')

        msg = _('The cluster (host_cluster) contains no active nodes')
        self.assertEqual(msg, ex.message)
        mock_nodes.assert_called_once_with(ctx, cluster_id='host_cluster',
                                           filters={'status': 'ACTIVE'})

    def test_get_host_ip_nova_server(self):
        addresses = {
            'private': [{'version': 4, 'OS-EXT-IPS:type': 'fixed',
                         'addr': '1.2.3.4'}]
        }
        server = mock.Mock(addresses=addresses)
        cc = mock.Mock()
        cc.server_get.return_value = server
        profile = dp.DockerProfile('container', self.spec)
        profile._computeclient = cc
        obj = mock.Mock()
        host_ip = profile._get_host_ip(obj, 'fake_node', 'os.nova.server')
        self.assertEqual('1.2.3.4', host_ip)
        cc.server_get.assert_called_once_with('fake_node')

    def test_get_host_ip_heat_stack(self):
        oc = mock.Mock()
        stack = mock.Mock(
            outputs=[{'output_key': 'fixed_ip', 'output_value': '1.2.3.4'}]
        )
        oc.stack_get.return_value = stack
        profile = dp.DockerProfile('container', self.spec)
        profile._orchestrationclient = oc
        obj = mock.Mock()

        host_ip = profile._get_host_ip(obj, 'fake_node', 'os.heat.stack')

        self.assertEqual('1.2.3.4', host_ip)
        oc.stack_get.assert_called_once_with('fake_node')

    def test_get_host_ip_heat_stack_no_outputs(self):
        oc = mock.Mock()
        stack = mock.Mock(outputs=None)
        oc.stack_get.return_value = stack
        profile = dp.DockerProfile('container', self.spec)
        profile._orchestrationclient = oc
        obj = mock.Mock()

        ex = self.assertRaises(exc.InternalError,
                               profile._get_host_ip,
                               obj, 'fake_node', 'os.heat.stack')

        msg = _("Output 'fixed_ip' is missing from the provided stack node")

        self.assertEqual(msg, ex.message)

    def test_do_validate_with_cluster_and_node(self):
        spec = copy.deepcopy(self.spec)
        spec['properties']['host_cluster'] = 'fake_cluster'
        obj = mock.Mock()
        profile = dp.DockerProfile('container', spec)

        ex = self.assertRaises(exc.InvalidSpec,
                               profile.do_validate, obj)

        self.assertEqual("Either 'host_cluster' or 'host_node' must be "
                         "specified, but not both.", str(ex))

    def test_do_validate_with_neither_cluster_or_node(self):
        spec = copy.deepcopy(self.spec)
        del spec['properties']['host_node']
        obj = mock.Mock()
        profile = dp.DockerProfile('container', spec)

        ex = self.assertRaises(exc.InvalidSpec,
                               profile.do_validate, obj)

        self.assertEqual("Either 'host_cluster' or 'host_node' must be "
                         "specified.", str(ex))

    @mock.patch.object(no.Node, 'find')
    def test_do_validate_with_node(self, mock_find):
        obj = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)
        mock_find.return_value = mock.Mock()

        res = profile.do_validate(obj)

        self.assertIsNone(res)
        mock_find.assert_called_once_with(profile.context, 'fake_node')

    @mock.patch.object(no.Node, 'find')
    def test_do_validate_node_not_found(self, mock_find):
        obj = mock.Mock()
        profile = dp.DockerProfile('container', self.spec)
        mock_find.side_effect = exc.ResourceNotFound(type='node',
                                                     id='fake_node')

        ex = self.assertRaises(exc.InvalidSpec,
                               profile.do_validate, obj)

        self.assertEqual("The specified host_node 'fake_node' could not be "
                         "found or is not unique.", str(ex))
        mock_find.assert_called_once_with(profile.context, 'fake_node')

    @mock.patch.object(co.Cluster, 'find')
    def test_do_validate_with_cluster(self, mock_find):
        spec = copy.deepcopy(self.spec)
        obj = mock.Mock()
        del spec['properties']['host_node']
        spec['properties']['host_cluster'] = 'fake_cluster'
        profile = dp.DockerProfile('container', spec)
        mock_find.return_value = mock.Mock()

        res = profile.do_validate(obj)

        self.assertIsNone(res)
        mock_find.assert_called_once_with(profile.context, 'fake_cluster')

    @mock.patch.object(co.Cluster, 'find')
    def test_do_validate_cluster_not_found(self, mock_find):
        spec = copy.deepcopy(self.spec)
        del spec['properties']['host_node']
        spec['properties']['host_cluster'] = 'fake_cluster'
        obj = mock.Mock()
        mock_find.side_effect = exc.ResourceNotFound(type='node',
                                                     id='fake_cluster')
        profile = dp.DockerProfile('container', spec)

        ex = self.assertRaises(exc.InvalidSpec,
                               profile.do_validate, obj)

        self.assertEqual("The specified host_cluster 'fake_cluster' could "
                         "not be found or is not unique.", str(ex))
        mock_find.assert_called_once_with(profile.context, 'fake_cluster')

    @mock.patch.object(db_api, 'node_add_dependents')
    @mock.patch.object(context, 'get_service_context')
    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_create(self, mock_docker, mock_ctx, mock_add):
        ctx = mock.Mock()
        mock_ctx.return_value = ctx
        dockerclient = mock.Mock()
        mock_docker.return_value = dockerclient
        container = {'Id': 'd' * 64}
        dockerclient.container_create.return_value = container
        container_id = 'd' * 36
        profile = dp.DockerProfile('container', self.spec)
        host = mock.Mock(id='node_id')
        profile.host = host
        profile.cluster = cluster
        profile.id = 'profile_id'
        obj = mock.Mock(id='fake_con_id')

        ret_container_id = profile.do_create(obj)

        mock_add.assert_called_once_with(ctx, 'node_id', 'fake_con_id')
        self.assertEqual(container_id, ret_container_id)
        params = {
            'image': 'hello-world',
            'name': 'docker_container',
            'command': '/bin/sleep 30',
        }
        dockerclient.container_create.assert_called_once_with(**params)

    @mock.patch.object(context, 'get_service_context')
    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_create_failed(self, mock_docker, mock_ctx):
        mock_ctx.return_value = mock.Mock()
        mock_docker.side_effect = exc.InternalError

        profile = dp.DockerProfile('container', self.spec)

        obj = mock.Mock()
        self.assertRaises(exc.EResourceCreation,
                          profile.do_create, obj)

        mock_ctx.assert_called_once_with(project=obj.project, user=obj.user)

    @mock.patch.object(context, 'get_admin_context')
    @mock.patch.object(db_api, 'node_remove_dependents')
    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_delete(self, mock_docker, mock_rem, mock_ctx):
        obj = mock.Mock(id='container1', physical_id='FAKE_PHYID')
        dockerclient = mock.Mock()
        ctx = mock.Mock()
        mock_ctx.return_value = ctx
        mock_docker.return_value = dockerclient
        host = mock.Mock(dependents={})
        host.id = 'node_id'
        profile = dp.DockerProfile('container', self.spec)
        profile.host = host
        profile.id = 'profile_id'

        res = profile.do_delete(obj)

        self.assertIsNone(res)
        mock_rem.assert_called_once_with(ctx, 'node_id', 'container1')
        dockerclient.container_delete.assert_any_call('FAKE_PHYID')

    def test_do_delete_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        profile = dp.DockerProfile('container', self.spec)
        self.assertIsNone(profile.do_delete(obj))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_delete_failed(self, mock_docker):
        obj = mock.Mock(physical_id='FAKE_ID')
        mock_docker.side_effect = exc.InternalError

        profile = dp.DockerProfile('container', self.spec)

        self.assertRaises(exc.EResourceDeletion,
                          profile.do_delete, obj)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_update_name(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)
        res = docker._update_name(obj, 'NEW_NAME')

        self.assertIsNone(res)
        x_docker.rename.assert_called_once_with('FAKE_ID', 'NEW_NAME')

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_update_name_docker_failure(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        x_docker.rename.side_effect = exc.InternalError(message='BOOM')
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceUpdate,
                               docker._update_name,
                               obj, 'NEW_NAME')

        self.assertEqual("Failed in updating container 'FAKE_ID': BOOM.",
                         str(ex))
        x_docker.rename.assert_called_once_with('FAKE_ID', 'NEW_NAME')

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_update(self, mock_docker):
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        new_spec = {
            'type': 'container.dockerinc.docker',
            'version': '1.0',
            'properties': {
                'context': {
                    'region_name': 'RegionOne'
                },
                'name': 'new_name',
                'image': 'hello-world',
                'command': '/bin/sleep 30',
                'port': 2375,
                'host_node': 'fake_node',
            }
        }
        new_profile = dp.DockerProfile('u', new_spec)
        res = docker.do_update(obj, new_profile)

        self.assertTrue(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_do_update_no_new_profile(self, mock_docker):
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        params = {}
        res = docker.do_update(obj, params)

        self.assertFalse(res)

    def test_do_update_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        profile = dp.DockerProfile('container', self.spec)
        self.assertFalse(profile.do_update(obj))

    def test_check_container_name(self):
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        new_spec = {
            'type': 'container.dockerinc.docker',
            'version': '1.0',
            'properties': {
                'context': {
                    'region_name': 'RegionOne'
                },
                'name': 'new_name',
                'image': 'hello-world',
                'command': '/bin/sleep 30',
                'port': 2375,
                'host_node': 'fake_node',
            }
        }
        new_profile = dp.DockerProfile('u', new_spec)
        res, new_name = docker._check_container_name(obj, new_profile)

        self.assertTrue(res)

    def test_check_container_same_name(self):
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        new_spec = {
            'type': 'container.dockerinc.docker',
            'version': '1.0',
            'properties': {
                'context': {
                    'region_name': 'RegionOne'
                },
                'name': 'docker_container',
                'image': 'hello-world',
                'command': '/bin/sleep 30',
                'port': 2375,
                'host_node': 'fake_node',
            }
        }
        new_profile = dp.DockerProfile('u', new_spec)
        res, new_name = docker._check_container_name(obj, new_profile)

        self.assertFalse(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_reboot(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_reboot(obj)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.restart.assert_called_once_with('FAKE_ID')

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_reboot_with_timeout(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_reboot(obj, timeout=200)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.restart.assert_called_once_with('FAKE_ID', timeout=200)

    def test_handle_reboot_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_reboot(obj)

        self.assertIsNone(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_reboot_driver_failure(self, mock_docker):
        mock_docker.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_reboot,
                               obj)

        self.assertEqual("Failed in rebooting container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_reboot_docker_failure(self, mock_docker):
        x_docker = mock.Mock()
        mock_docker.return_value = x_docker
        x_docker.restart.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_reboot,
                               obj)

        self.assertEqual("Failed in rebooting container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_pause(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_pause(obj)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.pause.assert_called_once_with('FAKE_ID')

    def test_handle_pause_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_pause(obj)

        self.assertIsNone(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_pause_driver_failure(self, mock_docker):
        mock_docker.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_pause,
                               obj)

        self.assertEqual("Failed in pausing container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_pause_docker_failure(self, mock_docker):
        x_docker = mock.Mock()
        mock_docker.return_value = x_docker
        x_docker.pause.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_pause,
                               obj)

        self.assertEqual("Failed in pausing container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_unpause(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_unpause(obj)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.unpause.assert_called_once_with('FAKE_ID')

    def test_handle_unpause_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_unpause(obj)

        self.assertIsNone(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_unpause_driver_failure(self, mock_docker):
        mock_docker.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_unpause,
                               obj)

        self.assertEqual("Failed in unpausing container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_unpause_docker_failure(self, mock_docker):
        x_docker = mock.Mock()
        mock_docker.return_value = x_docker
        x_docker.unpause.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_unpause,
                               obj)

        self.assertEqual("Failed in unpausing container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_stop(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)
        params = {'timeout': None}
        res = docker.handle_stop(obj, **params)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.stop.assert_called_once_with('FAKE_ID', **params)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_stop_with_timeout(self, mock_docker):
        x_docker = mock.Mock()
        x_docker = mock_docker.return_value
        obj = mock.Mock(physical_id='FAKE_ID')

        docker = dp.DockerProfile('container', self.spec)
        params = {'timeout': 200}
        res = docker.handle_stop(obj, **params)

        self.assertIsNone(res)
        mock_docker.assert_called_once_with(obj)
        x_docker.stop.assert_called_once_with('FAKE_ID', **params)

    def test_handle_stop_no_physical_id(self):
        obj = mock.Mock(physical_id=None)
        docker = dp.DockerProfile('container', self.spec)

        res = docker.handle_stop(obj)

        self.assertIsNone(res)

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_stop_driver_failure(self, mock_docker):
        mock_docker.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_stop,
                               obj)

        self.assertEqual("Failed in stop container 'FAKE_ID': "
                         "Boom.", str(ex))

    @mock.patch.object(dp.DockerProfile, 'docker')
    def test_handle_stop_docker_failure(self, mock_docker):
        x_docker = mock.Mock()
        mock_docker.return_value = x_docker
        x_docker.stop.side_effect = exc.InternalError(message="Boom")
        obj = mock.Mock(physical_id='FAKE_ID')
        docker = dp.DockerProfile('container', self.spec)

        ex = self.assertRaises(exc.EResourceOperation,
                               docker.handle_stop,
                               obj)

        self.assertEqual("Failed in stop container 'FAKE_ID': "
                         "Boom.", str(ex))
