# -*- coding: utf-8 -*-
#
#    Copyright 2015 Mirantis, Inc.
#
#    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 mock
import os
import yaml

import fuelclient
from fuelclient.cli import error
from fuelclient.cli import serializers
from fuelclient.objects import base as base_object
from fuelclient.objects import fuelversion as fuelversion_object
from fuelclient.tests.unit.v2.lib import test_api
from fuelclient.tests import utils


class TestNodeFacade(test_api.BaseLibTest):

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

        self.version = 'v1'
        self.res_uri = '/api/{version}/nodes/'.format(version=self.version)

        self.fake_node = utils.get_fake_node()
        self.fake_nodes = [utils.get_fake_node() for _ in range(10)]

        self.client = fuelclient.get_client('node', self.version)

    def test_node_list(self):
        matcher = self.m_request.get(self.res_uri, json=self.fake_nodes)
        self.client.get_all()

        self.assertTrue(matcher.called)

    def test_node_list_with_labels(self):
        labels = ['key1']
        fake_nodes = [
            utils.get_fake_node(
                node_name='node_1', labels={'key1': 'val1'}),
            utils.get_fake_node(
                node_name='node_2', labels={'key2': 'val2'}),
            utils.get_fake_node(
                node_name='node_3', labels={'key1': 'val2', 'key3': 'val3'})
        ]

        matcher_get = self.m_request.get(self.res_uri, json=fake_nodes)

        data = self.client.get_all(labels=labels)

        self.assertTrue(matcher_get.called)
        self.assertEqual(len(data), 2)
        self.assertEqual(data[0]['name'], 'node_1')
        self.assertEqual(data[1]['name'], 'node_3')

    def test_node_show(self):
        node_id = 42
        expected_uri = self.get_object_uri(self.res_uri, node_id)

        matcher = self.m_request.get(expected_uri, json=self.fake_node)

        self.client.get_by_id(node_id)

        self.assertTrue(matcher.called)

    @mock.patch.object(fuelversion_object.FuelVersion, 'get_feature_groups')
    def test_node_vms_list(self, m_feature_groups):
        node_id = 42
        expected_uri = "/api/v1/nodes/{0}/vms_conf/".format(node_id)
        m_feature_groups.return_value = \
            utils.get_fake_fuel_version()['feature_groups']

        fake_vms = [{'id': 1, 'opt2': 'val2'},
                    {'id': 2, 'opt4': 'val4'}]
        matcher = self.m_request.get(expected_uri, json=fake_vms)

        self.client.get_node_vms_conf(node_id)

        self.assertTrue(matcher.called)

    @mock.patch.object(fuelversion_object.FuelVersion, 'get_feature_groups')
    def test_node_vms_create(self, m_feature_groups):
        config = [{'id': 1, 'opt2': 'val2'},
                  {'id': 2, 'opt4': 'val4'}]
        node_id = 42
        m_feature_groups.return_value = \
            utils.get_fake_fuel_version()['feature_groups']

        expected_uri = "/api/v1/nodes/{0}/vms_conf/".format(node_id)
        expected_body = {'vms_conf': config}

        matcher = self.m_request.put(expected_uri, json=expected_body)

        self.client.node_vms_create(node_id, config)

        self.assertTrue(matcher.called)
        self.assertEqual(expected_body, matcher.last_request.json())

    def test_node_set_hostname(self):
        node_id = 42
        hostname = 'test-name'
        data = {"hostname": hostname}
        expected_uri = self.get_object_uri(self.res_uri, node_id)

        matcher = self.m_request.put(expected_uri, json=data)

        self.client.update(node_id, **data)

        self.assertTrue(matcher.called)
        self.assertEqual(data, matcher.last_request.json())

    def test_get_all_labels_for_all_nodes(self):
        matcher = self.m_request.get(self.res_uri, json=self.fake_nodes)
        self.client.get_all_labels_for_nodes()

        self.assertTrue(matcher.called)

    def test_set_labels_for_all_nodes(self):
        labels = ['key_1=val_1', 'key_2=val_2', 'key_3   =   val_4']
        data = {'labels': {
            'key_1': 'val_1',
            'key_2': 'val_2',
            'key_3': 'val_4'
        }}

        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(self.res_uri, json=self.fake_nodes)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.set_labels_for_nodes(labels=labels)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_set_labels_for_specific_nodes(self):
        labels = ['key_1=val_1', 'key_2=val_2', 'key_3   =   val_4']
        node_ids = ['42']
        data = {'labels': {
            'key_1': 'val_1',
            'key_2': 'val_2',
            'key_3': 'val_4'
        }}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(expected_uri, json=self.fake_node)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.set_labels_for_nodes(labels=labels, node_ids=node_ids)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_set_labels_with_empty_key(self):
        labels = ['key_1=val_1', ' =   val_2', 'key_3   = ']
        node_ids = ['42']

        msg = 'Wrong label "{0}" was provided. Label key couldn\'t ' \
              'be an empty string.'.format(labels[1])
        with self.assertRaisesRegexp(error.LabelEmptyKeyError, msg):
            self.client.set_labels_for_nodes(labels=labels, node_ids=node_ids)

    def test_delete_specific_labels_for_all_nodes(self):
        labels = ['key_1', '   key_3   ']
        data = {'labels': {'key_2': None}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(self.res_uri, json=self.fake_nodes)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.delete_labels_for_nodes(labels=labels)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_delete_specific_labels_for_specific_nodes(self):
        labels = ['key_2']
        node_ids = ['42']
        data = {'labels': {'key_1': 'val_1', 'key_3': 'val_3'}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(expected_uri, json=self.fake_node)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.delete_labels_for_nodes(labels=labels, node_ids=node_ids)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_delete_all_labels_for_all_nodes(self):
        data = {'labels': {}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(self.res_uri, json=self.fake_nodes)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.delete_labels_for_nodes(labels=None)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_delete_all_labels_for_specific_nodes(self):
        node_ids = ['42']
        data = {'labels': {}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        matcher_get = self.m_request.get(expected_uri, json=self.fake_node)
        matcher_put = self.m_request.put(expected_uri, json=data)

        self.client.delete_labels_for_nodes(labels=None, node_ids=node_ids)

        self.assertTrue(matcher_get.called)
        self.assertTrue(matcher_put.called)
        self.assertEqual(data, matcher_put.last_request.json())

    def test_delete_labels_by_value(self):
        labels = ['key_1=val_1', 'key_3=anothervalue', 'key_2']
        node_ids = ['42']
        result_labels = {'labels': {'key_3': 'val_3'}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        self.m_request.get(expected_uri, json=self.fake_node)
        matcher_put = self.m_request.put(expected_uri, json=self.fake_node)

        self.client.delete_labels_for_nodes(
            labels=labels, node_ids=node_ids)

        self.assertTrue(matcher_put.called)
        self.assertEqual(result_labels, matcher_put.last_request.json())

    def test_delete_labels_by_value_with_whitespace(self):
        labels = ['key_1    =val_1', 'key_3=    anothervalue', 'key_2']
        node_ids = ['42']
        result_labels = {'labels': {'key_3': 'val_3'}}
        expected_uri = self.get_object_uri(self.res_uri, 42)

        self.m_request.get(expected_uri, json=self.fake_node)
        matcher_put = self.m_request.put(expected_uri, json=self.fake_node)

        self.client.delete_labels_for_nodes(
            labels=labels, node_ids=node_ids)

        self.assertTrue(matcher_put.called)
        self.assertEqual(result_labels, matcher_put.last_request.json())

    def test_get_name_and_value_from_labels(self):
        for label in (
            'key=value',
            '   key   =value',
            'key=    value    ',
            '  key  =  value   ',
        ):
            name, value, has_separator = self.client._split_label(label)
            self.assertEqual(name, 'key')
            self.assertEqual(value, 'value')
            self.assertTrue(has_separator)

    def test_get_name_and_empty_value_from_lables(self):
        for label in (
            'key=',
            '   key   =',
            'key=        ',
            '  key  =     ',
        ):
            name, value, has_separator = self.client._split_label(label)
            self.assertEqual(name, 'key')
            self.assertIsNone(value)
            self.assertTrue(has_separator)

    def test_get_name_without_separator(self):
        for label in (
            'key',
            '   key   ',
        ):
            name, value, has_separator = self.client._split_label(label)
            self.assertEqual(name, 'key')
            self.assertIsNone(value)
            self.assertFalse(has_separator)

    def test_label_with_many_separators(self):
        label = 'key1=  key2  = val2'
        name, value, has_separator = self.client._split_label(label)
        self.assertEqual(name, 'key1')
        self.assertEqual(value, 'key2  = val2')
        self.assertTrue(has_separator)

    def test_labels_after_delete(self):
        all_labels = {
            'label_A': 'A',
            'label_B': None,
            'label_C': 'C',
            'label_D': None,
        }
        expected_labels = {
            'label_A': 'A',
            'label_D': None,
        }

        for labels_to_delete in (
            ('label_B', 'label_C'),
            ('   label_B', 'label_C   '),
            ('label_B', 'label_C  ', 'unknown_label'),
            ('label_A =   trololo', 'label_B=', 'label_C =C', 'label_D=value')
        ):
            result = self.client._labels_after_delete(
                all_labels, labels_to_delete)
            self.assertEqual(result, expected_labels)

    @mock.patch.object(base_object.BaseObject, 'init_with_data')
    def test_node_update(self, m_init):
        node_id = 42
        expected_uri = self.get_object_uri(self.res_uri, node_id)

        get_matcher = self.m_request.get(expected_uri, json=self.fake_node)
        upd_matcher = self.m_request.put(expected_uri, json=self.fake_node)

        self.client.update(node_id, hostname="new-name")

        self.assertTrue(expected_uri, get_matcher.called)
        self.assertTrue(expected_uri, upd_matcher.called)

        req_data = upd_matcher.last_request.json()
        self.assertEqual('new-name', req_data['hostname'])

    def test_node_update_wrong_attribute(self):
        node_id = 42
        self.assertRaises(error.BadDataException,
                          self.client.update, node_id, status=42)

    @mock.patch('fuelclient.objects.node.os.mkdir', mock.Mock())
    def test_node_attributes_download(self):
        node_id = 42
        expected_uri = self.get_object_uri(
            self.res_uri, node_id, '/attributes/')
        fake_attributes = {
            'attribute_name': 'attribute_value'
        }

        m_get = self.m_request.get(expected_uri, json=fake_attributes)

        m_open = mock.mock_open()
        with mock.patch('fuelclient.cli.serializers.open',
                        m_open, create=True):
            self.client.download_attributes(node_id, directory='/fake/dir')

        self.assertTrue(m_get.called)
        m_open.assert_called_once_with(
            '/fake/dir/node_{0}/attributes.yaml'.format(node_id), mock.ANY)
        serializer = serializers.Serializer()
        m_open().write.assert_called_once_with(
            serializer.serialize(fake_attributes))

    def test_node_disks_upload(self):
        node_id = 42
        new_disks = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        disks_uri = os.path.join(node_uri, 'disks/')

        get_matcher = self.m_request.get(node_uri, json=self.fake_node)
        upd_matcher = self.m_request.put(disks_uri, json={})

        self.client.set_disks(node_id, new_disks)

        self.assertTrue(node_uri, get_matcher.called)
        self.assertTrue(disks_uri, upd_matcher.called)

        req_data = upd_matcher.last_request.json()
        self.assertEqual(new_disks, req_data)

    def test_node_disks_download(self):
        node_id = 42
        fake_resp = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        disks_uri = os.path.join(node_uri, 'disks/')

        node_matcher = self.m_request.get(node_uri, json=self.fake_node)
        disks_matcher = self.m_request.get(disks_uri, json=fake_resp)

        disks = self.client.get_disks(node_id)

        self.assertTrue(node_uri, node_matcher.called)
        self.assertTrue(disks_uri, disks_matcher.called)

        self.assertEqual(disks, fake_resp)

    def test_node_disks_defaults(self):
        node_id = 42
        fake_resp = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        disks_uri = os.path.join(node_uri, 'disks/defaults')

        node_matcher = self.m_request.get(node_uri, json=self.fake_node)
        disks_matcher = self.m_request.get(disks_uri, json=fake_resp)

        disks = self.client.get_default_disks(node_id)

        self.assertTrue(node_uri, node_matcher.called)
        self.assertTrue(disks_uri, disks_matcher.called)

        self.assertEqual(disks, fake_resp)

    @mock.patch('fuelclient.objects.node.os.path.exists',
                mock.Mock(return_value=True))
    def test_node_attribute_upload(self):
        node_id = 42
        expected_uri = self.get_object_uri(
            self.res_uri, node_id, '/attributes/')
        fake_attributes = {
            'attribute_name': 'attribute_value'
        }

        m_put = self.m_request.put(expected_uri, json=fake_attributes)

        m_open = mock.mock_open(read_data=yaml.safe_dump(fake_attributes))
        with mock.patch('fuelclient.cli.serializers.open',
                        m_open, create=True):
            self.client.upload_attributes(node_id, directory='/fake/dir')

        self.assertTrue(m_put.called)
        m_open.assert_called_once_with(
            '/fake/dir/node_{0}/attributes.yaml'.format(node_id), mock.ANY)
        self.assertEqual(m_put.last_request.json(), fake_attributes)
        m_open().read.assert_called_once_with()

    def test_node_interfaces_upload(self):
        node_id = 42
        new_interfaces = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        interfaces_uri = os.path.join(node_uri, 'interfaces/')

        get_matcher = self.m_request.get(node_uri, json=self.fake_node)
        upd_matcher = self.m_request.put(interfaces_uri, json={})

        self.client.set_interfaces(node_id, new_interfaces)

        self.assertTrue(node_uri, get_matcher.called)
        self.assertTrue(interfaces_uri, upd_matcher.called)

        req_data = upd_matcher.last_request.json()
        self.assertEqual(new_interfaces, req_data)

    def test_node_interfaces_download(self):
        node_id = 42
        fake_resp = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        interfaces_uri = os.path.join(node_uri, 'interfaces/')

        node_matcher = self.m_request.get(node_uri, json=self.fake_node)
        interfaces_matcher = self.m_request.get(interfaces_uri, json=fake_resp)

        interfaces = self.client.get_interfaces(node_id)

        self.assertTrue(node_uri, node_matcher.called)
        self.assertTrue(interfaces_uri, interfaces_matcher.called)

        self.assertEqual(interfaces, fake_resp)

    def test_node_interfaces_default(self):
        node_id = 42
        fake_resp = {'test_key': u'test ☃ value'}

        node_uri = self.get_object_uri(self.res_uri, node_id)
        interfaces_uri = os.path.join(node_uri,
                                      'interfaces/default_assignment')

        node_matcher = self.m_request.get(node_uri, json=self.fake_node)
        interfaces_matcher = self.m_request.get(interfaces_uri, json=fake_resp)

        interfaces = self.client.get_default_interfaces(node_id)

        self.assertTrue(node_uri, node_matcher.called)
        self.assertTrue(interfaces_uri, interfaces_matcher.called)

        self.assertEqual(interfaces, fake_resp)

    def test_undiscover_nodes_by_id_force(self):
        node_id = 42
        expected_uri = '/api/v1/nodes/?ids={node_id}'.format(node_id=node_id)
        request_url = self.get_object_uri(self.res_uri, node_id)

        node_matcher = self.m_request.get(request_url, json=self.fake_node)
        matcher = self.m_request.delete(expected_uri, json={})

        self.client.undiscover_nodes(node_id=node_id, force=True)

        self.assertTrue(matcher.called)
        self.assertTrue(node_matcher.called)
        self.assertEqual([str(node_id)], matcher.last_request.qs.get('ids'))

    def test_undiscover_nodes_by_id(self):
        node_id = 42
        expected_uri = self.get_object_uri(self.res_uri, node_id)
        node_matcher = self.m_request.get(expected_uri, json=self.fake_node)

        self.assertRaises(error.ActionException,
                          self.client.undiscover_nodes,
                          node_id=node_id, force=False)
        self.assertTrue(node_matcher.called)

    def test_undiscover_nodes_by_env_force(self):
        env_id = 24
        node_ids = ['42', '43', '44']
        expected_uri = '/api/v1/nodes/?ids={node_ids}'.format(
            node_ids=','.join(node_ids))
        fake_nodes = [utils.get_fake_node(node_name='node_' + n_id,
                                          node_id=n_id,
                                          cluster=env_id) for n_id in node_ids]

        nodes_matcher = self.m_request.get(self.res_uri, json=fake_nodes)
        matcher = self.m_request.delete(expected_uri, json={})

        self.client.undiscover_nodes(env_id=env_id, node_id=None, force=True)

        self.assertTrue(matcher.called)
        self.assertTrue(nodes_matcher.called)
        self.assertEqual([','.join(node_ids)],
                         matcher.last_request.qs.get('ids'))

    def test_undiscover_nodes_by_env(self):
        env_id = 24
        node_ids = ['42', '43', '44']
        fake_nodes = [utils.get_fake_node(node_name='node_' + n_id,
                                          node_id=n_id,
                                          cluster=env_id) for n_id in node_ids]
        nodes_matcher = self.m_request.get(self.res_uri, json=fake_nodes)

        self.assertRaises(error.ActionException,
                          self.client.undiscover_nodes,
                          env_id=env_id, node_id=None, force=False)
        self.assertTrue(nodes_matcher.called)

    def test_undiscover_nodes_w_wrong_params(self):
        env_id = None
        node_id = None

        self.assertRaises(ValueError,
                          self.client.undiscover_nodes,
                          env_id=env_id, node_id=node_id, force=False)