← Back to branch summary

~ubuntu-branches/ubuntu/quantal/nova/quantal-proposed

« back to all changes in this revision

Viewing changes to nova/tests/test_db_api.py

  • Committer: Package Import Robot
  • Author(s): Adam Gandelman, Adam Gandelman, Chuck Short
  • Date: 2012-08-27 15:37:18 UTC
  • mfrom: (1.1.60)
  • Revision ID: package-import@ubuntu.com-20120827153718-lj8er44eqqz1gsrj
Tags: 2012.2~rc1~20120827.15815-0ubuntu1
https://launchpad.net/bugs/820694
[ Adam Gandelman ]
* New upstream release.

[ Chuck Short ]
* debian/patches/0001-Update-tools-hacking-for-pep8-1.2-and-
  beyond.patch: Dropped we dont run pep8 tests anymore.
* debian/control: Drop pep8 build depends
* debian/*.upstart.in: Make sure we transition correctly from runlevel
  1 to 2. (LP: #820694)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_db_api.py
214
214
        self.assertRaises(exception.DuplicateVlan,
215
215
                          db.network_create_safe, ctxt, values2)
216
216
 
217
 
    def test_instance_update_with_instance_id(self):
218
 
        """ test instance_update() works when an instance id is passed """
219
 
        ctxt = context.get_admin_context()
220
 
 
221
 
        # Create an instance with some metadata
222
 
        values = {'metadata': {'host': 'foo'},
223
 
                  'system_metadata': {'original_image_ref': 'blah'}}
224
 
        instance = db.instance_create(ctxt, values)
225
 
 
226
 
        # Update the metadata
227
 
        values = {'metadata': {'host': 'bar'},
228
 
                  'system_metadata': {'original_image_ref': 'baz'}}
229
 
        db.instance_update(ctxt, instance['uuid'], values)
230
 
 
231
 
        # Retrieve the user-provided metadata to ensure it was successfully
232
 
        # updated
233
 
        instance_meta = db.instance_metadata_get(ctxt, instance.uuid)
234
 
        self.assertEqual('bar', instance_meta['host'])
235
 
 
236
 
        # Retrieve the system metadata to ensure it was successfully updated
237
 
        system_meta = db.instance_system_metadata_get(ctxt, instance.uuid)
238
 
        self.assertEqual('baz', system_meta['original_image_ref'])
239
 
 
240
217
    def test_instance_update_with_instance_uuid(self):
241
218
        """ test instance_update() works when an instance UUID is passed """
242
219
        ctxt = context.get_admin_context()
887
864
 
888
865
        self.compute_node_dict = dict(vcpus=2, memory_mb=1024, local_gb=2048,
889
866
                                 vcpus_used=0, memory_mb_used=0,
890
 
                                 local_gb_used=0, hypervisor_type="xen",
 
867
                                 local_gb_used=0, free_ram_mb=1024,
 
868
                                 free_disk_gb=2048, hypervisor_type="xen",
891
869
                                 hypervisor_version=1, cpu_info="",
 
870
                                 running_vms=0, current_workload=0,
892
871
                                 service_id=self.service.id)
 
872
        # add some random stats
 
873
        stats = dict(num_instances=3, num_proj_12345=2,
 
874
                     num_proj_23456=2, num_vm_building=3)
 
875
        self.compute_node_dict['stats'] = stats
893
876
 
894
877
        self.flags(reserved_host_memory_mb=0)
895
878
        self.flags(reserved_host_disk_mb=0)
898
881
        self.compute_node_dict['host'] = host
899
882
        return db.compute_node_create(self.ctxt, self.compute_node_dict)
900
883
 
 
884
    def _stats_as_dict(self, stats):
 
885
        d = {}
 
886
        for s in stats:
 
887
            key = s['key']
 
888
            d[key] = s['value']
 
889
        return d
 
890
 
901
891
    def test_compute_node_create(self):
902
892
        item = self._create_helper('host1')
903
893
        self.assertEquals(item.free_ram_mb, 1024)
905
895
        self.assertEquals(item.running_vms, 0)
906
896
        self.assertEquals(item.current_workload, 0)
907
897
 
908
 
    def test_compute_node_create_with_reservations(self):
909
 
        self.flags(reserved_host_memory_mb=256)
910
 
        item = self._create_helper('host1')
911
 
        self.assertEquals(item.free_ram_mb, 1024 - 256)
912
 
 
913
 
    def test_compute_node_set(self):
914
 
        self._create_helper('host1')
915
 
 
916
 
        x = db.compute_node_utilization_set(self.ctxt, 'host1',
917
 
                            free_ram_mb=2048, free_disk_gb=4096)
918
 
        self.assertEquals(x.free_ram_mb, 2048)
919
 
        self.assertEquals(x.free_disk_gb, 4096)
920
 
        self.assertEquals(x.running_vms, 0)
921
 
        self.assertEquals(x.current_workload, 0)
922
 
 
923
 
        x = db.compute_node_utilization_set(self.ctxt, 'host1', work=3)
924
 
        self.assertEquals(x.free_ram_mb, 2048)
925
 
        self.assertEquals(x.free_disk_gb, 4096)
926
 
        self.assertEquals(x.current_workload, 3)
927
 
        self.assertEquals(x.running_vms, 0)
928
 
 
929
 
        x = db.compute_node_utilization_set(self.ctxt, 'host1', vms=5)
930
 
        self.assertEquals(x.free_ram_mb, 2048)
931
 
        self.assertEquals(x.free_disk_gb, 4096)
932
 
        self.assertEquals(x.current_workload, 3)
933
 
        self.assertEquals(x.running_vms, 5)
934
 
 
935
 
    def test_compute_node_utilization_update(self):
936
 
        self._create_helper('host1')
937
 
 
938
 
        x = db.compute_node_utilization_update(self.ctxt, 'host1',
939
 
                                               free_ram_mb_delta=-24)
940
 
        self.assertEquals(x.free_ram_mb, 1000)
941
 
        self.assertEquals(x.free_disk_gb, 2048)
942
 
        self.assertEquals(x.running_vms, 0)
943
 
        self.assertEquals(x.current_workload, 0)
944
 
 
945
 
        x = db.compute_node_utilization_update(self.ctxt, 'host1',
946
 
                                               free_disk_gb_delta=-48)
947
 
        self.assertEquals(x.free_ram_mb, 1000)
948
 
        self.assertEquals(x.free_disk_gb, 2000)
949
 
        self.assertEquals(x.running_vms, 0)
950
 
        self.assertEquals(x.current_workload, 0)
951
 
 
952
 
        x = db.compute_node_utilization_update(self.ctxt, 'host1',
953
 
                                               work_delta=3)
954
 
        self.assertEquals(x.free_ram_mb, 1000)
955
 
        self.assertEquals(x.free_disk_gb, 2000)
956
 
        self.assertEquals(x.current_workload, 3)
957
 
        self.assertEquals(x.running_vms, 0)
958
 
 
959
 
        x = db.compute_node_utilization_update(self.ctxt, 'host1',
960
 
                                               work_delta=-1)
961
 
        self.assertEquals(x.free_ram_mb, 1000)
962
 
        self.assertEquals(x.free_disk_gb, 2000)
963
 
        self.assertEquals(x.current_workload, 2)
964
 
        self.assertEquals(x.running_vms, 0)
965
 
 
966
 
        x = db.compute_node_utilization_update(self.ctxt, 'host1',
967
 
                                               vm_delta=5)
968
 
        self.assertEquals(x.free_ram_mb, 1000)
969
 
        self.assertEquals(x.free_disk_gb, 2000)
970
 
        self.assertEquals(x.current_workload, 2)
971
 
        self.assertEquals(x.running_vms, 5)
 
898
        stats = self._stats_as_dict(item['stats'])
 
899
        self.assertEqual(3, stats['num_instances'])
 
900
        self.assertEqual(2, stats['num_proj_12345'])
 
901
        self.assertEqual(3, stats['num_vm_building'])
 
902
 
 
903
    def test_compute_node_get_all(self):
 
904
        item = self._create_helper('host1')
 
905
        nodes = db.compute_node_get_all(self.ctxt)
 
906
        self.assertEqual(1, len(nodes))
 
907
 
 
908
        node = nodes[0]
 
909
        self.assertEqual(2, node['vcpus'])
 
910
 
 
911
        stats = self._stats_as_dict(node['stats'])
 
912
        self.assertEqual(3, int(stats['num_instances']))
 
913
        self.assertEqual(2, int(stats['num_proj_12345']))
 
914
        self.assertEqual(3, int(stats['num_vm_building']))
 
915
 
 
916
    def test_compute_node_update(self):
 
917
        item = self._create_helper('host1')
 
918
 
 
919
        compute_node_id = item['id']
 
920
        stats = self._stats_as_dict(item['stats'])
 
921
 
 
922
        # change some values:
 
923
        stats['num_instances'] = 8
 
924
        stats['num_tribbles'] = 1
 
925
        values = {
 
926
            'vcpus': 4,
 
927
            'stats': stats,
 
928
        }
 
929
        item = db.compute_node_update(self.ctxt, compute_node_id, values)
 
930
        stats = self._stats_as_dict(item['stats'])
 
931
 
 
932
        self.assertEqual(4, item['vcpus'])
 
933
        self.assertEqual(8, int(stats['num_instances']))
 
934
        self.assertEqual(2, int(stats['num_proj_12345']))
 
935
        self.assertEqual(1, int(stats['num_tribbles']))
 
936
 
 
937
    def test_compute_node_stat_prune(self):
 
938
        item = self._create_helper('host1')
 
939
        for stat in item['stats']:
 
940
            if stat['key'] == 'num_instances':
 
941
                num_instance_stat = stat
 
942
                break
 
943
 
 
944
        values = {
 
945
            'stats': dict(num_instances=1)
 
946
        }
 
947
        db.compute_node_update(self.ctxt, item['id'], values, prune_stats=True)
 
948
        item = db.compute_node_get_all(self.ctxt)[0]
 
949
        self.assertEqual(1, len(item['stats']))
 
950
 
 
951
        stat = item['stats'][0]
 
952
        self.assertEqual(num_instance_stat['id'], stat['id'])
 
953
        self.assertEqual(num_instance_stat['key'], stat['key'])
 
954
        self.assertEqual(1, int(stat['value']))
972
955
 
973
956
 
974
957
class TestIpAllocation(test.TestCase):