# Copyright (c) 2018 Amdocs
#
# 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.

import unittest
import mock
import json
from rest_framework import status
from aria.cli.core import aria

from multicloud_azure.swagger.views.infra_workload.views import InfraWorkload
from multicloud_azure.swagger.views.infra_workload.views import GetStackView
from multicloud_azure.pub.aria.service import AriaServiceImpl


class InfraViewTest(unittest.TestCase):

    def setUp(self):
        self.fsv = InfraWorkload()

    def tearDown(self):
        pass

    def test_service_get_fail(self):
        req = mock.Mock()
        dict = {'infra-template': 'aria', 'infra-payload': json.dumps(
            {'name': 'abc', 'template_data': {'stack_name': 'stack'}})}
        req.data = dict
        resp = self.fsv.post(req, "abc", "def")
        self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                         resp.status_code)


class StackViewTest(unittest.TestCase):

    def setUp(self):
        self.fsv = GetStackView()

    def tearDown(self):
        pass

    def test_service_get_fail(self):

        class Request:
            def __init__(self, query_params):
                self.query_params = query_params
        req = Request({'k': 'v'})
        self.assertNotEqual(status.HTTP_500_INTERNAL_SERVER_ERROR,
                            self.fsv.get(req, "abc", "def", 123))


class WorkoadViewTest(unittest.TestCase):

    def setUp(self):
        self.fsv = AriaServiceImpl()

    def tearDown(self):
        pass

    @mock.patch.object(AriaServiceImpl, 'deploy_service')
    def test_deploy_service(self, mock_service_info):

        class Service:
            def __init__(self, name, body, input, logger):
                self.name = name
                self.body = body
                self.input = input
                self.logger = logger
        s = Service("abc", "def", "ghi", "OK")
        mock_service_info.return_value = s
        service_op = AriaServiceImpl()
        self.assertNotEqual(200, service_op.deploy_service("a1", "b1", "c1",
                                                           "OK"))

    @mock.patch.object(AriaServiceImpl, 'install_template_private')
    @aria.pass_model_storage
    @aria.pass_resource_storage
    @aria.pass_plugin_manager
    @aria.pass_logger
    def test_install_template(self, mock_template_info, model_storage,
                              resource_storage, plugin_manager, logger):

        class Workload:
            def __init__(self, name, body):
                self.name = name
                self.body = body
        service = Workload("a", "w1")
        mock_template_info.return_value = service

        class Request:
            def __init__(self, query_params):
                self.query_params = query_params
        req = Request({'k': 'v'})
        self.assertNotEqual(200,
                            self.fsv.install_template_private(req, "a1", "b1",
                                                              model_storage,
                                                              resource_storage,
                                                              plugin_manager,
                                                              logger))

    @mock.patch.object(AriaServiceImpl, 'create_service')
    @aria.pass_model_storage
    @aria.pass_resource_storage
    @aria.pass_plugin_manager
    @aria.pass_logger
    def test_create_service(self, mock_template_info, model_storage,
                            resource_storage, plugin_manager, logger):
        class Workload:
            def __init__(self, id, name, input):
                self.id = id
                self.name = name
                self.input = input

        f1 = Workload(1, "a", "w1")
        f2 = Workload(2, "b", "w2")
        service = [f1, f2]
        mock_template_info.return_value = service

        class Request:
            def __init__(self, query_params):
                self.query_params = query_params

        req = Request({'k': 'v'})
        self.assertNotEqual(200,
                            self.fsv.create_service(req, 123, "a1", "b1",
                                                    model_storage,
                                                    resource_storage,
                                                    plugin_manager,
                                                    logger))

    def test_show_execution(self):
        service_op = AriaServiceImpl()
        self.assertNotEqual(200,
                            service_op.show_execution(123))