# 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.

import marvin
from marvin.cloudstackTestCase import *
from marvin.cloudstackAPI import *
from marvin.lib.utils import *
from marvin.lib.base import *
from marvin.lib.common import *
from marvin.lib.utils import (random_gen)
from nose.plugins.attrib import attr
from marvin.lib.decoratorGenerators import skipTestIf

import time

_multiprocess_shared_ = True

class TestMetrics(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        cls.apiclient = cls.testClient.getApiClient()
        cls.hypervisor = cls.testClient.getHypervisorInfo()
        cls.dbclient = cls.testClient.getDbConnection()
        cls.services = cls.testClient.getParsedTestDataConfig()
        cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
        cls.pod = get_pod(cls.apiclient, cls.zone.id)
        cls.host = list_hosts(cls.apiclient,
                               zoneid=cls.zone.id,
                               type='Routing')[0]
        cls.cluster = cls.apiclient.listClusters(listClusters.listClustersCmd())[0]
        cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__
        cls._cleanup = []
        cls.disk_offering = DiskOffering.create(
            cls.apiclient,
            cls.services["disk_offering"]
        )
        cls._cleanup.append(cls.disk_offering)
        cls.service_offering = ServiceOffering.create(
            cls.apiclient,
            cls.services["service_offering"]
        )
        cls._cleanup.append(cls.service_offering)
        cls.template = get_test_template(
            cls.apiclient,
            cls.zone.id,
            cls.hypervisor
        )
        cls.domain = get_domain(cls.apiclient)
        cls.account = Account.create(
            cls.apiclient,
            cls.services["account"],
            admin=False,
            domainid=cls.domain.id
        )
        cls._cleanup.append(cls.account)
        cls.hypervisorNotSupported = True
        if cls.hypervisor.lower() != 'simulator':
            cls.hypervisorNotSupported = False
            cls.vm_stats_interval_cfg = Configurations.list(cls.apiclient, name='vm.stats.interval')[0].value
            cls.vm_stats_max_retention_time_cfg = Configurations.list(cls.apiclient, name='vm.stats.max.retention.time')[0].value
            cls.vm_stats_user_vm_only_cfg = Configurations.list(cls.apiclient, name='vm.stats.user.vm.only')[0].value
            cls.vm_disk_stats_interval_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.interval')[0].value
            cls.vm_disk_stats_interval_min_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.interval.min')[0].value
            cls.vm_disk_stats_max_retention_time_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.max.retention.time')[0].value
            cls.vm_disk_stats_retention_enabled_cfg = Configurations.list(cls.apiclient, name='vm.disk.stats.retention.enabled')[0].value
            Configurations.update(cls.apiclient, 'vm.stats.interval', value='60000')
            Configurations.update(cls.apiclient, 'vm.stats.max.retention.time', value='7200')
            Configurations.update(cls.apiclient, 'vm.stats.user.vm.only', value='false')
            Configurations.update(cls.apiclient, 'vm.disk.stats.interval', value='60')
            Configurations.update(cls.apiclient, 'vm.disk.stats.interval.min', value='60')
            Configurations.update(cls.apiclient, 'vm.disk.stats.max.retention.time', value='7200')
            Configurations.update(cls.apiclient, 'vm.disk.stats.retention.enabled', value='true')
            cls.restartServer()

    @classmethod
    def tearDownClass(cls):
        if cls.hypervisor.lower() != 'simulator':
            cls.updateConfiguration('vm.stats.interval', cls.vm_stats_interval_cfg)
            cls.updateConfiguration('vm.stats.max.retention.time', cls.vm_stats_max_retention_time_cfg)
            cls.updateConfiguration('vm.stats.user.vm.only', cls.vm_stats_user_vm_only_cfg)
            cls.updateConfiguration('vm.disk.stats.interval', cls.vm_disk_stats_interval_cfg)
            cls.updateConfiguration('vm.disk.stats.interval.min', cls.vm_disk_stats_interval_min_cfg)
            cls.updateConfiguration('vm.disk.stats.max.retention.time', cls.vm_disk_stats_max_retention_time_cfg)
            cls.updateConfiguration('vm.disk.stats.retention.enabled', cls.vm_disk_stats_retention_enabled_cfg)
            cls.restartServer()
        super(TestMetrics, cls).tearDownClass()

    @classmethod
    def restartServer(cls):
        """Restart management server"""

        cls.debug("Restarting management server")
        sshClient = SshClient(
                    cls.mgtSvrDetails["mgtSvrIp"],
            22,
            cls.mgtSvrDetails["user"],
            cls.mgtSvrDetails["passwd"]
        )
        command = "service cloudstack-management stop"
        sshClient.execute(command)

        command = "service cloudstack-management start"
        sshClient.execute(command)

        #Waits for management to come up in 5 mins, when it's up it will continue
        timeout = time.time() + 300
        while time.time() < timeout:
            if cls.isManagementUp() is True:
                # allow hosts to be ready for deployment
                time.sleep(30)
                return
            time.sleep(5)
        cls.setup_failed = True
        cls.debug("Management server did not come up, failing")
        return

    @classmethod
    def isManagementUp(cls):
        try:
            cls.apiclient.listInfrastructure(listInfrastructure.listInfrastructureCmd())
            return True
        except Exception:
            return False

    @classmethod
    def updateConfiguration(cls, config, value):
        if value is not None:
            Configurations.update(cls.apiclient, config, value=value)

    def setUp(self):
        self.userapiclient = self.testClient.getUserApiClient(
            UserName=self.account.name,
            DomainName=self.account.domain
        )
        self.cleanup = []

    def tearDown(self):
        super(TestMetrics, self).tearDown()

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_hosts_metrics(self):

        cmd = listHostsMetrics.listHostsMetricsCmd()
        cmd.id = self.host.id
        cmd.type = 'Routing'

        host_metric = self.apiclient.listHostsMetrics(cmd)[0]

        self.assertEqual(host_metric.cpuallocated, self.host.cpuallocated)
        self.assertEqual(host_metric.memoryallocated, self.host.memoryallocated)

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_clusters_metrics(self):

        cmd = listClustersMetrics.listClustersMetricsCmd()
        cmd.id = self.cluster.id

        cluster_metric = self.apiclient.listClustersMetrics(cmd)[0]

        self.assertEqual(cluster_metric.id, self.cluster.id)
        self.assertTrue(hasattr(cluster_metric, 'cpuallocated'))
        self.assertTrue(hasattr(cluster_metric, 'cpumaxdeviation'))
        self.assertTrue(hasattr(cluster_metric, 'memoryallocated'))
        self.assertTrue(hasattr(cluster_metric, 'memoryused'))
        self.assertTrue(hasattr(cluster_metric, 'memorymaxdeviation'))

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_zones_metrics(self):
        cmd = listZonesMetrics.listZonesMetricsCmd()
        cmd.id = self.zone.id

        zone_metrics = self.apiclient.listZonesMetrics(cmd)[0]

        self.assertTrue(hasattr(zone_metrics, 'cpuallocated'))
        self.assertTrue(hasattr(zone_metrics, 'cpumaxdeviation'))
        self.assertTrue(hasattr(zone_metrics, 'cputotal'))
        self.assertTrue(hasattr(zone_metrics, 'cpuused'))
        self.assertTrue(hasattr(zone_metrics, 'memoryallocated'))
        self.assertTrue(hasattr(zone_metrics, 'memorymaxdeviation'))
        self.assertTrue(hasattr(zone_metrics, 'memoryused'))

        return

    def run_list_vm_metrics_test(self, is_user):
        apiclient = self.apiclient
        if is_user:
            apiclient = self.userapiclient
        self.small_virtual_machine = VirtualMachine.create(
            apiclient,
            self.services["virtual_machine"],
            serviceofferingid=self.service_offering.id,
            templateid=self.template.id,
            zoneid=self.zone.id
        )
        self.cleanup.append(self.small_virtual_machine)


        cmd = listVirtualMachinesMetrics.listVirtualMachinesMetricsCmd()
        cmd.id = self.small_virtual_machine.id

        lvmm = apiclient.listVirtualMachinesMetrics(cmd)[0]

        self.assertEqual(lvmm.id, self.small_virtual_machine.id)

        self.assertTrue(hasattr(lvmm, 'cputotal'))
        self.assertTrue(hasattr(lvmm, 'cpuused'))
        self.assertTrue(hasattr(lvmm, 'diskiowrite'))
        self.assertTrue(hasattr(lvmm, 'diskkbswrite'))
        self.assertTrue(hasattr(lvmm, 'networkread'))
        self.assertTrue(hasattr(lvmm, 'networkwrite'))

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_vms_metrics_admin(self):
        self.run_list_vm_metrics_test(False)

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_vms_metrics_user(self):
        self.run_list_vm_metrics_test(True)

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_pstorage_metrics(self):
        #list StoragePools
        sp = self.apiclient.listStoragePools(listStoragePools.listStoragePoolsCmd())[0]

        #list StoragePoolsMetrics
        cmd = listStoragePoolsMetrics.listStoragePoolsMetricsCmd()
        cmd.id = sp.id

        sp_metrics = self.apiclient.listStoragePoolsMetrics(cmd)[0]

        self.assertEqual(sp_metrics.disksizeallocated, sp.disksizeallocated)
        self.assertEqual(sp_metrics.state, sp.state)

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_volumes_metrics(self):
        volume = Volume.create(
            self.apiclient,
            self.services['volume'],
            zoneid=self.zone.id,
            diskofferingid=self.disk_offering.id
        )
        self.cleanup.append(volume)

        cmd = listVolumes.listVolumesCmd()
        cmd.id = volume.id

        lv = self.apiclient.listVolumes(cmd)[0]

        cmd = listVolumesMetrics.listVolumesMetricsCmd()
        cmd.id = lv.id
        lvm = self.apiclient.listVolumesMetrics(cmd)[0]

        self.assertEqual(lv.size, lvm.size)
        self.assertTrue(hasattr(lvm, 'diskBytesReadRate'))
        self.assertTrue(hasattr(lvm, 'diskBytesWriteRate'))
        self.assertTrue(hasattr(lvm, 'diskIopsReadRate'))
        self.assertTrue(hasattr(lvm, 'diskIopsWriteRate'))

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_infrastructure_metrics(self):
        cmd = listInfrastructure.listInfrastructureCmd()
        li = self.apiclient.listInfrastructure(cmd)

        self.assertTrue(hasattr(li, 'clusters'))
        self.assertEqual(li.clusters, len(self.apiclient.listClusters(listClusters.listClustersCmd())))
        self.assertTrue(hasattr(li, 'hosts'))

        self.assertEqual(li.hosts, len(list_hosts(self.apiclient,
            type='Routing')))

        self.assertTrue(hasattr(li, 'imagestores'))
        self.assertEqual(li.imagestores, len(self.apiclient.listImageStores(listImageStores.listImageStoresCmd())))

        self.assertTrue(hasattr(li, 'pods'))
        self.assertEqual(li.pods, len(self.apiclient.listPods(listPods.listPodsCmd())))

        self.assertTrue(hasattr(li, 'routers'))

        self.assertTrue(hasattr(li, 'storagepools'))
        self.assertEqual(li.storagepools, len(self.apiclient.listStoragePools(listStoragePools.listStoragePoolsCmd())))

        self.assertTrue(hasattr(li, 'zones'))
        self.assertEqual(li.zones, len(self.apiclient.listZones(listZones.listZonesCmd())))

        self.assertTrue(hasattr(li, 'systemvms'))
        self.assertTrue(hasattr(li, 'cpusockets'))

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic", "bla"], required_hardware="false")
    def test_list_management_server_metrics(self):
        cmd = listManagementServersMetrics.listManagementServersMetricsCmd()
        listMSMs = self.apiclient.listManagementServersMetrics(cmd)
        cmd = listManagementServers.listManagementServersCmd()
        listMSs= self.apiclient.listManagementServers(cmd)

        self.assertEqual(len(listMSMs), len(listMSs))

        metrics = listMSMs[0]
        self.assertTrue(hasattr(metrics, 'availableprocessors'))
        self.assertTrue(isinstance(metrics.availableprocessors, int))
        self.assertTrue(hasattr(metrics, 'agentcount'))
        self.assertTrue(isinstance(metrics.agentcount, int))
        self.assertTrue(hasattr(metrics, 'sessions'))
        self.assertTrue(isinstance(metrics.sessions, int))

        self.assertTrue(hasattr(metrics, 'heapmemoryused'))
        self.assertTrue(isinstance(metrics.heapmemoryused, int))
        self.assertTrue(hasattr(metrics, 'heapmemorytotal'))
        self.assertTrue(isinstance(metrics.heapmemorytotal, int))
        self.assertTrue(metrics.heapmemoryused <= metrics.heapmemorytotal)

        self.assertTrue(hasattr(metrics, 'threadsblockedcount'))
        self.assertTrue(isinstance(metrics.threadsblockedcount, int))
        self.assertTrue(hasattr(metrics, 'threadsdaemoncount'))
        self.assertTrue(isinstance(metrics.threadsdaemoncount, int))
        self.assertTrue(hasattr(metrics, 'threadsrunnablecount'))
        self.assertTrue(isinstance(metrics.threadsrunnablecount, int))
        self.assertTrue(hasattr(metrics, 'threadsteminatedcount'))
        self.assertTrue(isinstance(metrics.threadsteminatedcount, int))
        self.assertTrue(hasattr(metrics, 'threadstotalcount'))
        self.assertTrue(isinstance(metrics.threadstotalcount, int))
        self.assertTrue(hasattr(metrics, 'threadswaitingcount'))
        self.assertTrue(isinstance(metrics.threadswaitingcount, int))
        self.assertTrue(metrics.threadsblockedcount   <= metrics.threadstotalcount)
        self.assertTrue(metrics.threadsdaemoncount    <= metrics.threadstotalcount)
        self.assertTrue(metrics.threadsrunnablecount  <= metrics.threadstotalcount)
        self.assertTrue(metrics.threadsteminatedcount <= metrics.threadstotalcount)
        self.assertTrue(metrics.threadswaitingcount   <= metrics.threadstotalcount)

        self.assertTrue(hasattr(metrics, 'systemmemorytotal'))
        self.assertTrue(isinstance(metrics.systemmemorytotal, str))
        self.assertTrue(hasattr(metrics, 'systemmemoryfree'))
        self.assertTrue(isinstance(metrics.systemmemoryfree, str))
        self.assertTrue(hasattr(metrics, 'systemmemoryvirtualsize'))
        self.assertTrue(isinstance(metrics.systemmemoryvirtualsize, str))

        self.assertTrue(hasattr(metrics, 'loginfo'))
        self.assertTrue(isinstance(metrics.loginfo, str))
        self.assertTrue(hasattr(metrics, 'systemtotalcpucycles'))
        self.assertTrue(isinstance(metrics.systemtotalcpucycles, float))
        self.assertTrue(hasattr(metrics, 'systemloadaverages'))
        self.assertTrue(isinstance(metrics.systemloadaverages, list))
        self.assertEqual(len(metrics.systemloadaverages), 3)
        self.assertTrue(hasattr(metrics, 'systemcycleusage'))
        self.assertTrue(isinstance(metrics.systemcycleusage, list))
        self.assertEqual(len(metrics.systemcycleusage), 3)
        self.assertTrue(hasattr(metrics, 'dbislocal'))
        self.assertTrue(isinstance(metrics.dbislocal, bool))
        self.assertTrue(hasattr(metrics, 'usageislocal'))
        self.assertTrue(isinstance(metrics.usageislocal, bool))
        self.assertTrue(hasattr(metrics, 'collectiontime'))
        self.assertTrue(isinstance(metrics.collectiontime, str))
        self.assertTrue(self.valid_date(metrics.collectiontime))
        self.assertTrue(hasattr(metrics, 'id'))
        self.assertTrue(isinstance(metrics.id, str))
        self.assertTrue(hasattr(metrics, 'name'))
        self.assertTrue(isinstance(metrics.name, str))
        self.assertTrue(hasattr(metrics, 'state'))
        self.assertEqual(metrics.state, 'Up')
        self.assertTrue(hasattr(metrics, 'version'))
        self.assertTrue(isinstance(metrics.version, str))
        self.assertTrue(hasattr(metrics, 'javadistribution'))
        self.assertTrue(isinstance(metrics.javadistribution, str))
        self.assertTrue(hasattr(metrics, 'javaversion'))
        self.assertTrue(isinstance(metrics.javaversion, str))
        self.assertTrue(hasattr(metrics, 'osdistribution'))
        self.assertTrue(isinstance(metrics.osdistribution, str))
        self.assertTrue(hasattr(metrics, 'lastserverstart'))
        self.assertTrue(isinstance(metrics.lastserverstart, str))
        self.assertTrue(self.valid_date(metrics.lastserverstart))
        if hasattr(metrics, 'lastserverstop') and metrics.lastserverstop:
            self.debug(f"=== lastserverstop {metrics.lastserverstop} ===")
            self.assertTrue(isinstance(metrics.lastserverstop, str))
            self.assertTrue(self.valid_date(metrics.lastserverstop))
        self.assertTrue(hasattr(metrics, 'lastboottime'))
        self.assertTrue(isinstance(metrics.lastboottime, str))
        self.assertTrue(self.valid_date(metrics.lastboottime))

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_usage_server_metrics(self):
        cmd = listUsageServerMetrics.listUsageServerMetricsCmd()
        metrics = self.apiclient.listUsageServerMetrics(cmd)

        self.assertTrue(hasattr(metrics,'collectiontime'))
        self.assertTrue(isinstance(metrics.collectiontime, str))
        self.assertTrue(self.valid_date(metrics.collectiontime))
        self.assertTrue(hasattr(metrics, 'hostname'))
        self.assertTrue(isinstance(metrics.hostname, str))
        if hasattr(metrics, 'lastheartbeat') and metrics.lastheartbeat :
            self.debug(f"=== lastheartbeat {metrics.lastheartbeat} ===")
            self.assertTrue(isinstance(metrics.lastheartbeat, str))
            self.assertTrue(self.valid_date(metrics.lastheartbeat))
        if hasattr(metrics, 'lastsuccessfuljob') and metrics.lastsuccessfuljob:
            self.debug(f"=== lastsuccessfuljob {metrics.lastsuccessfuljob} ===")
            self.assertTrue(isinstance(metrics.lastsuccessfuljob, str))
            self.assertTrue(self.valid_date(metrics.lastsuccessfuljob))
        self.assertTrue(hasattr(metrics, 'state'))
        self.assertTrue(metrics.state == 'Up' or metrics.state == 'Down')

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    def test_list_db_metrics(self):
        cmd = listDbMetrics.listDbMetricsCmd()
        metrics = self.apiclient.listDbMetrics(cmd)

        self.assertTrue(hasattr(metrics,'collectiontime'))
        self.assertTrue(isinstance(metrics.collectiontime, str))
        self.assertTrue(self.valid_date(metrics.collectiontime))
        self.assertTrue(hasattr(metrics, 'connections'))
        self.assertTrue(isinstance(metrics.connections, int))

        cmd = listConfigurations.listConfigurationsCmd()
        cmd.name = 'database.server.stats.retention'
        configuration = self.apiclient.listConfigurations(cmd)
        retention = int(configuration[0].value)
        self.assertTrue(hasattr(metrics, 'dbloadaverages'))
        self.assertTrue(isinstance(metrics.dbloadaverages, list))
        self.assertTrue(len(metrics.dbloadaverages) <= retention)

        self.assertTrue(hasattr(metrics, 'hostname'))
        self.assertTrue(isinstance(metrics.hostname, str))
        self.assertTrue(hasattr(metrics, 'queries'))
        self.assertTrue(isinstance(metrics.queries, int))
        self.assertTrue(hasattr(metrics, 'replicas'))
        self.assertTrue(isinstance(metrics.replicas, list))
        self.assertTrue(hasattr(metrics, 'uptime'))
        self.assertTrue(isinstance(metrics.uptime, int))
        self.assertTrue(hasattr(metrics, 'version'))
        self.assertTrue(isinstance(metrics.version, str))
        self.assertTrue(hasattr(metrics, 'versioncomment'))
        self.assertTrue(isinstance(metrics.versioncomment, str))

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
    @skipTestIf("hypervisorNotSupported")
    def test_list_vms_metrics_history(self):
        #deploy VM
        self.small_virtual_machine = VirtualMachine.create(
                                        self.apiclient,
                                        self.services["virtual_machine"],
                                        serviceofferingid=self.service_offering.id,
                                        templateid=self.template.id,
                                        zoneid=self.zone.id
                                        )
        self.cleanup.append(self.small_virtual_machine)

        # Wait for 2 minutes
        time.sleep(120)

        cmd = listVirtualMachinesUsageHistory.listVirtualMachinesUsageHistoryCmd()
        cmd.id = self.small_virtual_machine.id

        result = self.apiclient.listVirtualMachinesUsageHistory(cmd)[0]

        self.assertEqual(result.id, self.small_virtual_machine.id)
        self.assertTrue(hasattr(result, 'stats'))
        self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
        self.validate_vm_stats(result.stats[0])

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
    @skipTestIf("hypervisorNotSupported")
    def test_list_system_vms_metrics_history(self):
        cmd = listSystemVmsUsageHistory.listSystemVmsUsageHistoryCmd()
        now = datetime.datetime.now() - datetime.timedelta(minutes=15)
        start_time = now.strftime("%Y-%m-%d %H:%M:%S")
        cmd.startdate = start_time

        result = self.apiclient.listSystemVmsUsageHistory(cmd)[0]

        self.assertTrue(hasattr(result, 'stats'))
        self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
        self.validate_vm_stats(result.stats[0])

        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
    @skipTestIf("hypervisorNotSupported")
    def test_list_volumes_metrics_history(self):
        #deploy VM
        self.small_virtual_machine = VirtualMachine.create(
                                        self.apiclient,
                                        self.services["virtual_machine"],
                                        serviceofferingid=self.service_offering.id,
                                        templateid=self.template.id,
                                        zoneid=self.zone.id
                                        )
        self.cleanup.append(self.small_virtual_machine)

        currentHost = Host.list(self.apiclient, id=self.small_virtual_machine.hostid)[0]
        if currentHost.hypervisor.lower() == "xenserver":
            # Skip tests as volume metrics doesn't see to work
            self.skipTest("Skipping test because volume metrics doesn't work on hypervisor\
                            %s, %s" % (currentHost.hypervisor, currentHost.hypervisorversion))

        # Wait for 2 minutes
        time.sleep(120)

        volume = Volume.list(
            self.apiclient,
            virtualmachineid=self.small_virtual_machine.id)[0]

        cmd = listVolumesUsageHistory.listVolumesUsageHistoryCmd()
        cmd.id = volume.id

        result = self.apiclient.listVolumesUsageHistory(cmd)[0]
        self.assertEqual(result.id, volume.id)
        self.assertTrue(hasattr(result, 'stats'))
        self.assertTrue(type(result.stats) == list and len(result.stats) > 0)
        stats = result.stats[0]
        self.assertTrue(hasattr(stats, 'diskioread'))
        self.assertTrue(hasattr(stats, 'diskiowrite'))
        self.assertTrue(hasattr(stats, 'diskiopstotal'))
        self.assertTrue(hasattr(stats, 'diskkbsread'))
        self.assertTrue(hasattr(stats, 'diskkbswrite'))
        self.assertTrue(hasattr(stats, 'timestamp'))
        self.assertTrue(self.valid_date(stats.timestamp))

        return

    def validate_vm_stats(self, stats):
        self.assertTrue(hasattr(stats, 'cpuused'))
        self.assertTrue(hasattr(stats, 'diskiopstotal'))
        self.assertTrue(hasattr(stats, 'diskioread'))
        self.assertTrue(hasattr(stats, 'diskiowrite'))
        self.assertTrue(hasattr(stats, 'diskkbsread'))
        self.assertTrue(hasattr(stats, 'diskkbswrite'))
        self.assertTrue(hasattr(stats, 'memoryintfreekbs'))
        self.assertTrue(hasattr(stats, 'memorykbs'))
        self.assertTrue(hasattr(stats, 'memorytargetkbs'))
        self.assertTrue(hasattr(stats, 'networkkbsread'))
        self.assertTrue(hasattr(stats, 'networkkbswrite'))
        self.assertTrue(hasattr(stats, 'networkread'))
        self.assertTrue(hasattr(stats, 'networkwrite'))
        self.assertTrue(hasattr(stats, 'timestamp'))
        self.assertTrue(self.valid_date(stats.timestamp))

    def valid_date(cls, date_text):
        try:
            datetime.datetime.strptime(date_text, '%Y-%m-%dT%H:%M:%S%z')
            return True
        except ValueError:
            return False