# Copyright 2013 Hewlett-Packard Development Company, L.P.
# All Rights Reserved.
#
#    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.
#

from unittest.mock import Mock
from unittest.mock import patch
from oslo_config.cfg import NoSuchOptError

from trove.common import exception
from trove.common import utils
from trove.extensions.common import models
from trove.extensions.common.service import ClusterRootController
from trove.extensions.common.service import DefaultRootController
from trove.extensions.common.service import RootController
from trove.instance import models as instance_models
from trove.instance.models import DBInstance
from trove.tests.unittests import trove_testtools


class TestDefaultRootController(trove_testtools.TestCase):

    def setUp(self):
        super(TestDefaultRootController, self).setUp()
        self.controller = DefaultRootController()

    @patch.object(models.Root, "load")
    def test_root_index(self, root_load):
        context = Mock()
        req = Mock()
        req.environ = Mock()
        req.environ.__getitem__ = Mock(return_value=context)
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = False
        self.controller.root_index(req, tenant_id, uuid, is_cluster)
        root_load.assert_called_with(context, uuid)

    def test_root_index_with_cluster(self):
        req = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = True
        self.assertRaises(
            exception.ClusterOperationNotSupported,
            self.controller.root_index,
            req, tenant_id, uuid, is_cluster)

    @patch.object(models.Root, "create")
    def test_root_create(self, root_create):
        user = Mock()
        context = Mock()
        context.user_id = Mock()
        context.user_id.__getitem__ = Mock(return_value=user)
        req = Mock()
        req.environ = Mock()
        req.environ.__getitem__ = Mock(return_value=context)
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = False
        password = Mock()
        body = {'password': password}
        self.controller.root_create(req, body, tenant_id, uuid, is_cluster)
        root_create.assert_called_with(context, uuid, password)

    def test_root_create_with_cluster(self):
        req = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = True
        password = Mock()
        body = {'password': password}
        self.assertRaises(
            exception.ClusterOperationNotSupported,
            self.controller.root_create,
            req, body, tenant_id, uuid, is_cluster)

    @patch.object(models.Root, "delete")
    @patch.object(models.Root, "load")
    def test_root_delete(self, root_load, root_delete):
        context = Mock()
        req = Mock()
        req.environ = Mock()
        req.environ.__getitem__ = Mock(return_value=context)
        tenant_id = Mock()
        instance_id = utils.generate_uuid()
        is_cluster = False
        root_load.return_value = True
        self.controller.root_delete(req, tenant_id, instance_id, is_cluster)
        root_load.assert_called_with(context, instance_id)
        root_delete.assert_called_with(context, instance_id)

    @patch.object(models.Root, "delete")
    @patch.object(models.Root, "load")
    def test_root_delete_without_root_enabled(self, root_load, root_delete):
        context = Mock()
        req = Mock()
        req.environ = Mock()
        req.environ.__getitem__ = Mock(return_value=context)
        tenant_id = Mock()
        instance_id = utils.generate_uuid()
        is_cluster = False
        root_load.return_value = False
        self.assertRaises(
            exception.RootHistoryNotFound,
            self.controller.root_delete,
            req, tenant_id, instance_id, is_cluster)
        root_load.assert_called_with(context, instance_id)
        root_delete.assert_not_called()

    def test_root_delete_with_cluster(self):
        req = Mock()
        tenant_id = Mock()
        instance_id = utils.generate_uuid()
        is_cluster = True
        self.assertRaises(
            exception.ClusterOperationNotSupported,
            self.controller.root_delete,
            req, tenant_id, instance_id, is_cluster)


class TestRootController(trove_testtools.TestCase):

    def setUp(self):
        super(TestRootController, self).setUp()
        self.context = trove_testtools.TroveTestContext(self)
        self.controller = RootController()

    @patch.object(instance_models.Instance, "load")
    @patch.object(RootController, "load_root_controller")
    @patch.object(RootController, "_get_datastore")
    def test_index(self, service_get_datastore, service_load_root_controller,
                   service_load_instance):
        req = Mock()
        req.environ = {'trove.context': self.context}
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        ds_manager = Mock()
        is_cluster = False
        service_get_datastore.return_value = (ds_manager, is_cluster)
        root_controller = Mock()
        ret = Mock()
        root_controller.root_index = Mock(return_value=ret)
        service_load_root_controller.return_value = root_controller

        self.assertEqual(ret, self.controller.index(req, tenant_id, uuid))
        service_get_datastore.assert_called_with(tenant_id, uuid)
        service_load_root_controller.assert_called_with(ds_manager)
        root_controller.root_index.assert_called_with(
            req, tenant_id, uuid, is_cluster)

    @patch.object(instance_models.Instance, "load")
    @patch.object(RootController, "load_root_controller")
    @patch.object(RootController, "_get_datastore")
    def test_create(self, service_get_datastore, service_load_root_controller,
                    service_load_instance):
        req = Mock()
        req.environ = {'trove.context': self.context}
        body = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        ds_manager = Mock()
        is_cluster = False
        service_get_datastore.return_value = (ds_manager, is_cluster)
        root_controller = Mock()
        ret = Mock()
        root_controller.root_create = Mock(return_value=ret)
        service_load_root_controller.return_value = root_controller

        self.assertEqual(
            ret, self.controller.create(req, tenant_id, uuid, body=body))
        service_get_datastore.assert_called_with(tenant_id, uuid)
        service_load_root_controller.assert_called_with(ds_manager)
        root_controller.root_create.assert_called_with(
            req, body, tenant_id, uuid, is_cluster)

    @patch.object(instance_models.Instance, "load")
    @patch.object(RootController, "load_root_controller")
    @patch.object(RootController, "_get_datastore")
    def test_create_with_no_root_controller(self,
                                            service_get_datastore,
                                            service_load_root_controller,
                                            service_load_instance):
        req = Mock()
        req.environ = {'trove.context': self.context}
        body = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        ds_manager = Mock()
        is_cluster = False
        service_get_datastore.return_value = (ds_manager, is_cluster)
        service_load_root_controller.return_value = None

        self.assertRaises(
            NoSuchOptError,
            self.controller.create,
            req, tenant_id, uuid, body=body)
        service_get_datastore.assert_called_with(tenant_id, uuid)
        service_load_root_controller.assert_called_with(ds_manager)

    @patch.object(instance_models.Instance, "load")
    @patch.object(RootController, "load_root_controller")
    @patch.object(RootController, "_get_datastore")
    def test_delete(self, service_get_datastore, service_load_root_controller,
                    service_load_instance):
        req = Mock()
        req.environ = {'trove.context': self.context}
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        ds_manager = Mock()
        is_cluster = False
        service_get_datastore.return_value = (ds_manager, is_cluster)
        root_controller = Mock()
        ret = Mock()
        root_controller.root_delete = Mock(return_value=ret)
        service_load_root_controller.return_value = root_controller

        self.assertEqual(
            ret, self.controller.delete(req, tenant_id, uuid))
        service_get_datastore.assert_called_with(tenant_id, uuid)
        service_load_root_controller.assert_called_with(ds_manager)
        root_controller.root_delete.assert_called_with(
            req, tenant_id, uuid, is_cluster)

    @patch.object(instance_models.Instance, "load")
    @patch.object(RootController, "load_root_controller")
    @patch.object(RootController, "_get_datastore")
    def test_delete_with_no_root_controller(self,
                                            service_get_datastore,
                                            service_load_root_controller,
                                            service_load_instance):
        req = Mock()
        req.environ = {'trove.context': self.context}
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        ds_manager = Mock()
        is_cluster = False
        service_get_datastore.return_value = (ds_manager, is_cluster)
        service_load_root_controller.return_value = None

        self.assertRaises(
            NoSuchOptError,
            self.controller.delete,
            req, tenant_id, uuid)
        service_get_datastore.assert_called_with(tenant_id, uuid)
        service_load_root_controller.assert_called_with(ds_manager)


class TestClusterRootController(trove_testtools.TestCase):

    def setUp(self):
        super(TestClusterRootController, self).setUp()
        self.context = trove_testtools.TroveTestContext(self)
        self.controller = ClusterRootController()

    @patch.object(ClusterRootController, "cluster_root_index")
    def test_root_index_cluster(self, mock_cluster_root_index):
        req = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = True
        self.controller.root_index(req, tenant_id, uuid, is_cluster)
        mock_cluster_root_index.assert_called_with(req, tenant_id, uuid)

    @patch.object(ClusterRootController, "instance_root_index")
    def test_root_index_instance(self, mock_instance_root_index):
        req = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = False
        self.controller.root_index(req, tenant_id, uuid, is_cluster)
        mock_instance_root_index.assert_called_with(req, tenant_id, uuid)

    @patch.object(ClusterRootController, "cluster_root_create")
    def test_root_create_cluster(self, mock_cluster_root_create):
        req = Mock()
        body = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = True
        self.controller.root_create(req, body, tenant_id, uuid, is_cluster)
        mock_cluster_root_create.assert_called_with(req, body, tenant_id, uuid)

    @patch.object(ClusterRootController, "check_cluster_instance_actions")
    @patch.object(ClusterRootController, "instance_root_create")
    def test_root_create_instance(self, mock_instance_root_create, mock_check):
        req = Mock()
        body = Mock()
        tenant_id = Mock()
        uuid = utils.generate_uuid()
        is_cluster = False
        self.controller.root_create(req, body, tenant_id, uuid, is_cluster)
        mock_check.assert_called_with(uuid)
        mock_instance_root_create.assert_called_with(req, body, uuid)

    @patch.object(models.ClusterRoot, "load")
    def test_instance_root_index(self, mock_cluster_root_load):
        req = Mock()
        req.environ = {'trove.context': self.context}
        tenant_id = Mock()
        instance_id = utils.generate_uuid()
        self.controller.instance_root_index(req, tenant_id, instance_id)
        mock_cluster_root_load.assert_called_with(self.context, instance_id)

    @patch.object(models.ClusterRoot, "load",
                  side_effect=exception.UnprocessableEntity())
    def test_instance_root_index_exception(self, mock_cluster_root_load):
        req = Mock()
        req.environ = {'trove.context': self.context}
        tenant_id = Mock()
        instance_id = utils.generate_uuid()
        self.assertRaises(
            exception.UnprocessableEntity,
            self.controller.instance_root_index,
            req, tenant_id, instance_id
        )
        mock_cluster_root_load.assert_called_with(self.context, instance_id)

    @patch.object(ClusterRootController, "instance_root_index")
    @patch.object(ClusterRootController, "_get_cluster_instance_id")
    def test_cluster_root_index(self, mock_get_cluster_instance,
                                mock_instance_root_index):
        req = Mock()
        tenant_id = Mock()
        cluster_id = utils.generate_uuid()
        single_instance_id = Mock()
        mock_get_cluster_instance.return_value = (single_instance_id, Mock())
        self.controller.cluster_root_index(req, tenant_id, cluster_id)
        mock_get_cluster_instance.assert_called_with(tenant_id, cluster_id)
        mock_instance_root_index.assert_called_with(req, tenant_id,
                                                    single_instance_id)

    @patch.object(ClusterRootController, "instance_root_create")
    @patch.object(ClusterRootController, "_get_cluster_instance_id")
    def test_cluster_root_create(self, mock_get_cluster_instance,
                                 mock_instance_root_create):
        req = Mock()
        body = Mock()
        tenant_id = Mock()
        cluster_id = utils.generate_uuid()
        single_instance_id = Mock()
        cluster_instances = Mock()
        mock_get_cluster_instance.return_value = (single_instance_id,
                                                  cluster_instances)
        self.controller.cluster_root_create(req, body, tenant_id, cluster_id)
        mock_get_cluster_instance.assert_called_with(tenant_id, cluster_id)
        mock_instance_root_create.assert_called_with(req, body,
                                                     single_instance_id,
                                                     cluster_instances)

    @patch.object(DBInstance, "find_all")
    def test_get_cluster_instance_id(self, mock_find_all):
        tenant_id = Mock()
        cluster_id = Mock()
        db_inst_1 = Mock()
        db_inst_1.id.return_value = utils.generate_uuid()
        db_inst_2 = Mock()
        db_inst_2.id.return_value = utils.generate_uuid()
        cluster_instances = [db_inst_1, db_inst_2]
        mock_find_all.return_value.all.return_value = cluster_instances
        ret = self.controller._get_cluster_instance_id(tenant_id, cluster_id)
        self.assertEqual(db_inst_1.id, ret[0])
        self.assertEqual([db_inst_1.id, db_inst_2.id], ret[1])

    @patch.object(models.ClusterRoot, "create")
    def test_instance_root_create(self, mock_cluster_root_create):
        user = Mock()
        self.context.user_id = Mock()
        self.context.user_id.__getitem__ = Mock(return_value=user)
        req = Mock()
        req.environ = {'trove.context': self.context}
        password = Mock()
        body = {'password': password}
        instance_id = utils.generate_uuid()
        cluster_instances = Mock()
        self.controller.instance_root_create(
            req, body, instance_id, cluster_instances)
        mock_cluster_root_create.assert_called_with(
            self.context, instance_id, password,
            cluster_instances)

    @patch.object(models.ClusterRoot, "create")
    def test_instance_root_create_no_body(self, mock_cluster_root_create):
        user = Mock()
        self.context.user_id = Mock()
        self.context.user_id.__getitem__ = Mock(return_value=user)
        req = Mock()
        req.environ = {'trove.context': self.context}
        password = None
        body = None
        instance_id = utils.generate_uuid()
        cluster_instances = Mock()
        self.controller.instance_root_create(
            req, body, instance_id, cluster_instances)
        mock_cluster_root_create.assert_called_with(
            self.context, instance_id, password,
            cluster_instances)
