# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
""" Tests for API listing of volumes with different filters
"""
# Import Local Modules
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.codes import FAILED
from marvin.lib.base import (Account,
                             Domain,
                             Volume,
                             ServiceOffering,
                             Tag,
                             DiskOffering,
                             VirtualMachine)
from marvin.lib.common import (get_domain, list_accounts,
                               list_zones, list_clusters, list_hosts, get_suitable_test_template)
# Import System modules
from nose.plugins.attrib import attr

_multiprocess_shared_ = True


class TestListVolumes(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        testClient = super(TestListVolumes, cls).getClsTestClient()
        cls.apiclient = testClient.getApiClient()
        cls.services = testClient.getParsedTestDataConfig()
        cls.hypervisor = testClient.getHypervisorInfo()
        cls.domain = get_domain(cls.apiclient)
        cls.zones = list_zones(cls.apiclient)
        cls.zone = cls.zones[0]
        cls.clusters = list_clusters(cls.apiclient)
        cls.cluster = cls.clusters[0]
        cls.hosts = list_hosts(cls.apiclient)
        cls.account = list_accounts(cls.apiclient, name="admin")[0]
        cls._cleanup = []

        cls.service_offering = ServiceOffering.create(
            cls.apiclient,
            cls.services["service_offerings"]["tiny"]
        )
        cls._cleanup.append(cls.service_offering)

        template = get_suitable_test_template(
            cls.apiclient,
            cls.zone.id,
            cls.services["ostype"],
            cls.hypervisor
        )
        if template == FAILED:
            assert False, "get_test_template() failed to return template"

        cls.services["template"]["ostypeid"] = template.ostypeid
        cls.services["template_2"]["ostypeid"] = template.ostypeid
        cls.services["ostypeid"] = template.ostypeid
        cls.services["virtual_machine"]["zoneid"] = cls.zone.id
        cls.services["mode"] = cls.zone.networktype

        cls.disk_offering = DiskOffering.create(cls.apiclient,
                                                cls.services["disk_offering"])
        cls._cleanup.append(cls.disk_offering)

        # Create VM
        cls.virtual_machine = VirtualMachine.create(
            cls.apiclient,
            cls.services["virtual_machine"],
            templateid=template.id,
            accountid=cls.account.name,
            domainid=cls.account.domainid,
            clusterid=cls.cluster.id,
            serviceofferingid=cls.service_offering.id,
            mode=cls.services["mode"]
        )

        cls.child_domain = Domain.create(
            cls.apiclient,
            cls.services["domain"])
        cls._cleanup.append(cls.child_domain)

        cls.child_account = Account.create(
            cls.apiclient,
            cls.services["account"],
            admin=True,
            domainid=cls.child_domain.id)
        cls._cleanup.append(cls.child_account)

        cls.vol_1 = Volume.create(cls.apiclient,
                                  cls.services["volume"],
                                  zoneid=cls.zone.id,
                                  account=cls.account.name,
                                  domainid=cls.account.domainid,
                                  diskofferingid=cls.disk_offering.id)
        cls._cleanup.append(cls.vol_1)

        cls.vol_1 = cls.virtual_machine.attach_volume(
            cls.apiclient,
            cls.vol_1
        )
        cls._cleanup.append(cls.virtual_machine)

        Tag.create(cls.apiclient, cls.vol_1.id, "Volume", {"abc": "xyz"})

        cls.vol_2 = Volume.create(cls.apiclient,
                                  cls.services["volume"],
                                  zoneid=cls.zone.id,
                                  account=cls.account.name,
                                  domainid=cls.account.domainid,
                                  diskofferingid=cls.disk_offering.id)

        cls._cleanup.append(cls.vol_2)

        cls.vol_3 = Volume.create(cls.apiclient,
                                  cls.services["volume"],
                                  zoneid=cls.zone.id,
                                  account=cls.child_account.name,
                                  domainid=cls.child_account.domainid,
                                  diskofferingid=cls.disk_offering.id)
        cls._cleanup.append(cls.vol_3)

    @classmethod
    def tearDownClass(cls):
        super(TestListVolumes, cls).tearDownClass()

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_01_list_volumes_account_domain_filter(self):
        """Test listing Volumes with account & domain filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            account=self.account.name,
            domainid=self.account.domainid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            3,
            "ListVolumes response expected 3 Volumes, received %s" % len(list_volume_response)
        )

        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            account=self.child_account.name,
            domainid=self.child_account.domainid
        )

        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 Volume, received %s" % len(list_volume_response)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_02_list_volumes_diskofferingid_filter(self):
        """Test listing Volumes with diskofferingid filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            account=self.account.name,
            domainid=self.account.domainid,
            diskofferingid=self.disk_offering.id
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_03_list_volumes_id_filter(self):
        """Test listing Volumes with id filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            id=self.vol_1.id
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 Volume, received %s" % len(list_volume_response)
        )
        self.assertEqual(
            list_volume_response[0].id,
            self.vol_1.id,
            "ListVolumes response expected Volume with id %s, received %s" % (self.vol_1.id, list_volume_response[0].id)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_04_list_volumes_ids_filter(self):
        """Test listing Volumes with ids filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            ids=[self.vol_1.id, self.vol_2.id, self.vol_3.id]
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(list_volume_response[0].id, [self.vol_1.id, self.vol_2.id],
                      "ListVolumes response Volume 1 not in list")
        self.assertIn(list_volume_response[1].id, [self.vol_1.id, self.vol_2.id],
                      "ListVolumes response Volume 2 not in list")

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_05_list_volumes_isrecursive(self):
        """Test listing Volumes with isrecursive filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            isrecursive=True,
            domainid=self.account.domainid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len([v for v in list_volume_response if v.state != "Destroy"]),
            4,
            "ListVolumes response expected 4 Volumes, received %s" % len(list_volume_response)
        )

        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            isrecursive=False,
            domainid=self.account.domainid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len([v for v in list_volume_response if v.state != "Destroy"]),
            3,
            "ListVolumes response expected 3 Volumes, received %s" % len(list_volume_response)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_06_list_volumes_keyword_filter(self):
        """Test listing Volumes with keyword filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            keyword=self.services["volume"]["diskname"]
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(
            list_volume_response[0].id, [self.vol_1.id, self.vol_2.id],
            "ListVolumes response Volume 1 not in list")
        self.assertIn(list_volume_response[1].id, [self.vol_1.id, self.vol_2.id],
                      "ListVolumes response Volume 2 not in list")

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_07_list_volumes_listall(self):
        """Test listing Volumes with listall filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            listall=True
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len([v for v in list_volume_response if v.state != "Destroy"]),
            4,
            "ListVolumes response expected 4 Volumes, received %s" % len(list_volume_response)
        )

        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            listall=False
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len([v for v in list_volume_response if v.state != "Destroy"]),
            3,
            "ListVolumes response expected 3 Volumes, received %s" % len(list_volume_response)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_08_listsystemvms(self):
        list_volumes_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            listsystemvms=True
        )
        self.assertEqual(
            isinstance(list_volumes_response, list),
            True,
            "List Volume response is not a valid list"
        )
        self.assertGreater(
            len(list_volumes_response),
            3,
            "ListVolumes response expected more than 3 Volumes, received %s" % len(list_volumes_response)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_09_list_volumes_name_filter(self):
        """Test listing Volumes with name filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            name=self.vol_1.name
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 Volumes, received %s" % len(list_volume_response)
        )
        self.assertEqual(
            list_volume_response[0].id,
            self.vol_1.id,
            "ListVolumes response expected Volume with id %s, received %s" % (self.vol_1.id, list_volume_response[0].id)
        )
        self.assertEqual(
            list_volume_response[0].name,
            self.vol_1.name,
            "ListVolumes response expected Volume with name %s, received %s" % (
                self.vol_1.name, list_volume_response[0].name)
        )

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_10_list_volumes_podid_filter(self):
        """Test listing Volumes with podid filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            podid=self.vol_1.podid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertGreater(
            len(list_volume_response),
            1,
            "ListVolumes response expected more than 1 Volume, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_11_list_volumes_state_filter(self):
        """Test listing Volumes with state filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            state="Ready"
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)

        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            state="Allocated"
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 Volumes, received %s" % len(list_volume_response)
        )
        self.assertEqual(self.vol_2.id, list_volume_response[0].id,
                         "ListVolumes response expected Volume with id %s" % self.vol_3.id)

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_12_list_volumes_storageid_filter(self):
        """Test listing Volumes with storageid filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            storageid=self.vol_1.storageid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertGreaterEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 or more Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_13_list_volumes_type_filter(self):
        """Test listing Volumes with type filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            type="DATADISK"
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)

        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            type="ROOT"
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 Volumes, received %s" % len(list_volume_response)
        )
        self.assertNotIn(list_volume_response[0].id, [self.vol_1.id, self.vol_2.id],
                         "ListVolumes response expected ROOT Volume")

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_14_list_volumes_virtualmachineid_filter(self):
        """Test listing Volumes with virtualmachineid filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id,
            virtualmachineid=self.vol_1.virtualmachineid
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            2,
            "ListVolumes response expected 2 Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_15_list_volumes_zoneid_filter(self):
        """Test listing Volumes with zoneid filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zones[0].id
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            3,
            "ListVolumes response expected 3 Volumes, received %s" % len(list_volume_response)
        )

        if len(self.zones) > 1:
            list_volume_response = Volume.list(
                self.apiclient,
                zoneid=self.zones[1].id
            )
            self.assertIsNone(list_volume_response, "List Volume response is not None")

    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_16_list_volumes_tags_filter(self):
        """Test listing Volumes with tags filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            tags=[{"key": "abc", "value": "xyz"}]
        )

        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertEqual(
            len(list_volume_response),
            1,
            "ListVolumes response expected 1 or more Volumes, received %s" % len(list_volume_response)
        )
        self.assertEqual(
            list_volume_response[0].id,
            self.vol_1.id,
            "ListVolumes response expected Volume with id %s, received %s" % (self.vol_1.id, list_volume_response[0].id)
        )
        self.assertEqual(
            list_volume_response[0].tags[0]["key"],
            "abc",
            "ListVolumes response expected Volume with tag key abc, received %s" % list_volume_response[0].tags[0]["key"]
        )
        self.assertEqual(
            list_volume_response[0].tags[0]["value"],
            "xyz",
            "ListVolumes response expected Volume with tag value xyz, received %s" % list_volume_response[0].tags[0]["value"]
        )

        list_volume_response = Volume.list(
            self.apiclient,
            tags=[{"key": "abc", "value": "xyz1"}]
        )
        self.assertIsNone(list_volume_response, "List Volume response is not None")
        with self.assertRaises(Exception):
            list_volume_response = Volume.list(
                self.apiclient,
                tags=[{"key": None, "value": None}]
            )


    @attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_17_list_volumes_no_filter(self):
        """Test listing Volumes with no filter
        """
        list_volume_response = Volume.list(
            self.apiclient,
            zoneid=self.zone.id
        )
        self.assertTrue(
            isinstance(list_volume_response, list),
            "List Volume response is not a valid list"
        )
        self.assertGreaterEqual(
            len(list_volume_response),
            3,
            "ListVolumes response expected 3 or more Volumes, received %s" % len(list_volume_response)
        )
        self.assertIn(self.vol_1.id, [volume.id for volume in list_volume_response],
                      "ListVolumes response expected Volume with id %s" % self.vol_1.id)