# Copyright 2012 Red Hat, 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.

from django.conf import settings
from django.test.utils import override_settings
import six

import cinderclient as cinder_client

from openstack_dashboard import api
from openstack_dashboard.test import helpers as test


class CinderApiTests(test.APITestCase):

    def test_volume_list(self):
        search_opts = {'all_tenants': 1}
        detailed = True
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts,).AndReturn(volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=detailed,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes = api.cinder.volume_list(self.request,
                                             search_opts=search_opts)
        self.assertEqual(len(volumes), len(api_volumes))

    def test_volume_list_paged(self):
        search_opts = {'all_tenants': 1}
        detailed = True
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts,).AndReturn(volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=detailed,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, has_more, has_prev = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts)
        self.assertEqual(len(volumes), len(api_volumes))
        self.assertFalse(has_more)
        self.assertFalse(has_prev)

    @override_settings(API_RESULT_PAGE_SIZE=2)
    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_volume_list_paginate_first_page(self):
        api.cinder.VERSIONS._active = None
        page_size = settings.API_RESULT_PAGE_SIZE
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()

        search_opts = {'all_tenants': 1}
        mox_volumes = volumes[:page_size + 1]
        expected_volumes = mox_volumes[:-1]

        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts, limit=page_size + 1,
                                  sort='created_at:desc', marker=None).\
            AndReturn(mox_volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=True,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, more_data, prev_data = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts, paginate=True)
        self.assertEqual(len(expected_volumes), len(api_volumes))
        self.assertTrue(more_data)
        self.assertFalse(prev_data)

    @override_settings(API_RESULT_PAGE_SIZE=2)
    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_volume_list_paginate_second_page(self):
        api.cinder.VERSIONS._active = None
        page_size = settings.API_RESULT_PAGE_SIZE
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()

        search_opts = {'all_tenants': 1}
        mox_volumes = volumes[page_size:page_size * 2 + 1]
        expected_volumes = mox_volumes[:-1]
        marker = expected_volumes[0].id

        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts, limit=page_size + 1,
                                  sort='created_at:desc', marker=marker).\
            AndReturn(mox_volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=True,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, more_data, prev_data = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts, marker=marker,
            paginate=True)
        self.assertEqual(len(expected_volumes), len(api_volumes))
        self.assertTrue(more_data)
        self.assertTrue(prev_data)

    @override_settings(API_RESULT_PAGE_SIZE=2)
    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_volume_list_paginate_last_page(self):
        api.cinder.VERSIONS._active = None
        page_size = settings.API_RESULT_PAGE_SIZE
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()

        search_opts = {'all_tenants': 1}
        mox_volumes = volumes[-1 * page_size:]
        expected_volumes = mox_volumes
        marker = expected_volumes[0].id

        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts, limit=page_size + 1,
                                  sort='created_at:desc', marker=marker).\
            AndReturn(mox_volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=True,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, more_data, prev_data = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts, marker=marker,
            paginate=True)
        self.assertEqual(len(expected_volumes), len(api_volumes))
        self.assertFalse(more_data)
        self.assertTrue(prev_data)

    @override_settings(API_RESULT_PAGE_SIZE=2)
    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_volume_list_paginate_back_from_some_page(self):
        api.cinder.VERSIONS._active = None
        page_size = settings.API_RESULT_PAGE_SIZE
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()

        search_opts = {'all_tenants': 1}
        mox_volumes = volumes[page_size:page_size * 2 + 1]
        expected_volumes = mox_volumes[:-1]
        marker = expected_volumes[0].id

        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts, limit=page_size + 1,
                                  sort='created_at:asc', marker=marker).\
            AndReturn(mox_volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=True,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, more_data, prev_data = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts, sort_dir="asc",
            marker=marker, paginate=True)
        self.assertEqual(len(expected_volumes), len(api_volumes))
        self.assertTrue(more_data)
        self.assertTrue(prev_data)

    @override_settings(API_RESULT_PAGE_SIZE=2)
    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_volume_list_paginate_back_to_first_page(self):
        api.cinder.VERSIONS._active = None
        page_size = settings.API_RESULT_PAGE_SIZE
        volumes = self.cinder_volumes.list()
        volume_transfers = self.cinder_volume_transfers.list()

        search_opts = {'all_tenants': 1}
        mox_volumes = volumes[:page_size]
        expected_volumes = mox_volumes
        marker = expected_volumes[0].id

        cinderclient = self.stub_cinderclient()
        cinderclient.volumes = self.mox.CreateMockAnything()
        cinderclient.volumes.list(search_opts=search_opts, limit=page_size + 1,
                                  sort='created_at:asc', marker=marker).\
            AndReturn(mox_volumes)
        cinderclient.transfers = self.mox.CreateMockAnything()
        cinderclient.transfers.list(
            detailed=True,
            search_opts=search_opts,).AndReturn(volume_transfers)
        self.mox.ReplayAll()

        api_volumes, more_data, prev_data = api.cinder.volume_list_paged(
            self.request, search_opts=search_opts, sort_dir="asc",
            marker=marker, paginate=True)
        self.assertEqual(len(expected_volumes), len(api_volumes))
        self.assertTrue(more_data)
        self.assertFalse(prev_data)

    def test_volume_snapshot_list(self):
        search_opts = {'all_tenants': 1}
        volume_snapshots = self.cinder_volume_snapshots.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.volume_snapshots = self.mox.CreateMockAnything()
        cinderclient.volume_snapshots.list(search_opts=search_opts).\
            AndReturn(volume_snapshots)
        self.mox.ReplayAll()

        api.cinder.volume_snapshot_list(self.request, search_opts=search_opts)

    def test_volume_snapshot_list_no_volume_configured(self):
        # remove volume from service catalog
        catalog = self.service_catalog
        for service in catalog:
            if service["type"] == "volume":
                self.service_catalog.remove(service)
        search_opts = {'all_tenants': 1}
        volume_snapshots = self.cinder_volume_snapshots.list()

        cinderclient = self.stub_cinderclient()
        cinderclient.volume_snapshots = self.mox.CreateMockAnything()
        cinderclient.volume_snapshots.list(search_opts=search_opts).\
            AndReturn(volume_snapshots)
        self.mox.ReplayAll()

        api.cinder.volume_snapshot_list(self.request, search_opts=search_opts)

    def test_volume_type_list_with_qos_associations(self):
        volume_types = self.cinder_volume_types.list()
        # Due to test data limitations, we can only run this test using
        # one qos spec, which is associated with one volume type.
        # If we use multiple qos specs, the test data will always
        # return the same associated volume type, which is invalid
        # and prevented by the UI.
        qos_specs_full = self.cinder_qos_specs.list()
        qos_specs_only_one = [qos_specs_full[0]]
        associations = self.cinder_qos_spec_associations.list()

        cinderclient = self.stub_cinderclient()
        cinderclient.volume_types = self.mox.CreateMockAnything()
        cinderclient.volume_types.list().AndReturn(volume_types)
        cinderclient.qos_specs = self.mox.CreateMockAnything()
        cinderclient.qos_specs.list().AndReturn(qos_specs_only_one)
        cinderclient.qos_specs.get_associations = self.mox.CreateMockAnything()
        cinderclient.qos_specs.get_associations(qos_specs_only_one[0].id).\
            AndReturn(associations)
        self.mox.ReplayAll()

        assoc_vol_types = \
            api.cinder.volume_type_list_with_qos_associations(self.request)
        associate_spec = assoc_vol_types[0].associated_qos_spec
        self.assertTrue(associate_spec, qos_specs_only_one[0].name)

    def test_volume_type_get_with_qos_association(self):
        volume_type = self.cinder_volume_types.first()
        qos_specs_full = self.cinder_qos_specs.list()
        qos_specs_only_one = [qos_specs_full[0]]
        associations = self.cinder_qos_spec_associations.list()

        cinderclient = self.stub_cinderclient()
        cinderclient.volume_types = self.mox.CreateMockAnything()
        cinderclient.volume_types.get(volume_type.id).AndReturn(volume_type)
        cinderclient.qos_specs = self.mox.CreateMockAnything()
        cinderclient.qos_specs.list().AndReturn(qos_specs_only_one)
        cinderclient.qos_specs.get_associations = self.mox.CreateMockAnything()
        cinderclient.qos_specs.get_associations(qos_specs_only_one[0].id).\
            AndReturn(associations)
        self.mox.ReplayAll()

        assoc_vol_type = \
            api.cinder.volume_type_get_with_qos_association(self.request,
                                                            volume_type.id)
        associate_spec = assoc_vol_type.associated_qos_spec
        self.assertTrue(associate_spec, qos_specs_only_one[0].name)

    def test_absolute_limits_with_negative_values(self):
        values = {"maxTotalVolumes": -1, "totalVolumesUsed": -1}
        expected_results = {"maxTotalVolumes": float("inf"),
                            "totalVolumesUsed": 0}

        limits = self.mox.CreateMockAnything()
        limits.absolute = []
        for key, val in six.iteritems(values):
            limit = self.mox.CreateMockAnything()
            limit.name = key
            limit.value = val
            limits.absolute.append(limit)

        cinderclient = self.stub_cinderclient()
        cinderclient.limits = self.mox.CreateMockAnything()
        cinderclient.limits.get().AndReturn(limits)
        self.mox.ReplayAll()

        ret_val = api.cinder.tenant_absolute_limits(self.request)
        for key in expected_results.keys():
            self.assertEqual(expected_results[key], ret_val[key])

    def test_pool_list(self):
        pools = self.cinder_pools.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.pools = self.mox.CreateMockAnything()
        cinderclient.pools.list(detailed=True).AndReturn(pools)
        self.mox.ReplayAll()

        # No assertions are necessary. Verification is handled by mox.
        api.cinder.pool_list(self.request, detailed=True)

    def test_volume_type_default(self):
        volume_type = self.cinder_volume_types.first()
        cinderclient = self.stub_cinderclient()
        cinderclient.volume_types = self.mox.CreateMockAnything()
        cinderclient.volume_types.default().AndReturn(volume_type)
        self.mox.ReplayAll()

        default_volume_type = api.cinder.volume_type_default(self.request)
        self.assertEqual(default_volume_type, volume_type)

    def test_cgroup_list(self):
        cgroups = self.cinder_consistencygroups.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.consistencygroups = self.mox.CreateMockAnything()
        cinderclient.consistencygroups.list(search_opts=None).\
            AndReturn(cgroups)
        self.mox.ReplayAll()
        api_cgroups = api.cinder.volume_cgroup_list(self.request)
        self.assertEqual(len(cgroups), len(api_cgroups))

    def test_cgroup_get(self):
        cgroup = self.cinder_consistencygroups.first()
        cinderclient = self.stub_cinderclient()
        cinderclient.consistencygroups = self.mox.CreateMockAnything()
        cinderclient.consistencygroups.get(cgroup.id).AndReturn(cgroup)
        self.mox.ReplayAll()
        api_cgroup = api.cinder.volume_cgroup_get(self.request, cgroup.id)
        self.assertEqual(api_cgroup.name, cgroup.name)
        self.assertEqual(api_cgroup.description, cgroup.description)
        self.assertEqual(api_cgroup.volume_types, cgroup.volume_types)

    def test_cgroup_list_with_vol_type_names(self):
        cgroups = self.cinder_consistencygroups.list()
        volume_types_list = self.cinder_volume_types.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.consistencygroups = self.mox.CreateMockAnything()
        cinderclient.consistencygroups.list(search_opts=None).\
            AndReturn(cgroups)
        cinderclient.volume_types = self.mox.CreateMockAnything()
        cinderclient.volume_types.list().AndReturn(volume_types_list)
        self.mox.ReplayAll()
        api_cgroups = api.cinder.volume_cgroup_list_with_vol_type_names(
            self.request)
        self.assertEqual(len(cgroups), len(api_cgroups))
        for i in range(len(api_cgroups[0].volume_type_names)):
            self.assertEqual(volume_types_list[i].name,
                             api_cgroups[0].volume_type_names[i])

    def test_cgsnapshot_list(self):
        cgsnapshots = self.cinder_cg_snapshots.list()
        cinderclient = self.stub_cinderclient()
        cinderclient.cgsnapshots = self.mox.CreateMockAnything()
        cinderclient.cgsnapshots.list(search_opts=None).\
            AndReturn(cgsnapshots)
        self.mox.ReplayAll()
        api_cgsnapshots = api.cinder.volume_cg_snapshot_list(self.request)
        self.assertEqual(len(cgsnapshots), len(api_cgsnapshots))

    def test_cgsnapshot_get(self):
        cgsnapshot = self.cinder_cg_snapshots.first()
        cinderclient = self.stub_cinderclient()
        cinderclient.cgsnapshots = self.mox.CreateMockAnything()
        cinderclient.cgsnapshots.get(cgsnapshot.id).AndReturn(cgsnapshot)
        self.mox.ReplayAll()
        api_cgsnapshot = api.cinder.volume_cg_snapshot_get(self.request,
                                                           cgsnapshot.id)
        self.assertEqual(api_cgsnapshot.name, cgsnapshot.name)
        self.assertEqual(api_cgsnapshot.description, cgsnapshot.description)
        self.assertEqual(api_cgsnapshot.consistencygroup_id,
                         cgsnapshot.consistencygroup_id)


class CinderApiVersionTests(test.TestCase):

    def setUp(self):
        super(CinderApiVersionTests, self).setUp()
        # The version is set when the module is loaded. Reset the
        # active version each time so that we can test with different
        # versions.
        api.cinder.VERSIONS._active = None

    def test_default_client_is_v2(self):
        client = api.cinder.cinderclient(self.request)
        self.assertIsInstance(client, cinder_client.v2.client.Client)

    @override_settings(OPENSTACK_API_VERSIONS={'volume': 2})
    def test_v2_setting_returns_v2_client(self):
        client = api.cinder.cinderclient(self.request)
        self.assertIsInstance(client, cinder_client.v2.client.Client)

    def test_get_v2_volume_attributes(self):
        # Get a v2 volume
        volume = self.cinder_volumes.get(name="v2_volume")
        self.assertTrue(hasattr(volume._apiresource, 'name'))
        self.assertFalse(hasattr(volume._apiresource, 'display_name'))

        name = "A v2 test volume name"
        description = "A v2 volume description"
        setattr(volume._apiresource, 'name', name)
        setattr(volume._apiresource, 'description', description)
        self.assertEqual(name, volume.name)
        self.assertEqual(description, volume.description)

    def test_get_v2_snapshot_attributes(self):
        # Get a v2 snapshot
        snapshot = self.cinder_volume_snapshots.get(
            description="v2 volume snapshot description")
        self.assertFalse(hasattr(snapshot._apiresource, 'display_name'))

        name = "A v2 test snapshot name"
        description = "A v2 snapshot description"
        setattr(snapshot._apiresource, 'name', name)
        setattr(snapshot._apiresource, 'description', description)
        self.assertEqual(name, snapshot.name)
        self.assertEqual(description, snapshot.description)

    def test_get_v2_snapshot_metadata(self):
        # Get a v2 snapshot with metadata
        snapshot = self.cinder_volume_snapshots.get(
            description="v2 volume snapshot with metadata description")
        self.assertTrue(hasattr(snapshot._apiresource, 'metadata'))
        self.assertFalse(hasattr(snapshot._apiresource, 'display_name'))

        key_name = "snapshot_meta_key"
        key_value = "snapshot_meta_value"
        metadata_value = {key_name: key_value}
        setattr(snapshot._apiresource, 'metadata', metadata_value)
        self.assertIn(key_name, snapshot.metadata.keys())
        self.assertEqual(key_value, snapshot.metadata['snapshot_meta_key'])

    def test_get_id_for_nameless_volume(self):
        volume = self.cinder_volumes.first()
        setattr(volume._apiresource, 'display_name', "")
        self.assertEqual(volume.id, volume.name)

    def test_adapt_dictionary_to_v2(self):
        volume = self.cinder_volumes.first()
        data = {'name': volume.name,
                'description': volume.description,
                'size': volume.size}

        ret_data = api.cinder._replace_v2_parameters(data)
        self.assertIn('name', ret_data.keys())
        self.assertIn('description', ret_data.keys())
        self.assertNotIn('display_name', ret_data.keys())
        self.assertNotIn('display_description', ret_data.keys())
