← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/nova/trunk

« back to all changes in this revision

Viewing changes to nova/tests/test_db_api.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Adam Gandelman
  • Date: 2012-06-22 12:39:57 UTC
  • mfrom: (1.1.57)
  • Revision ID: package-import@ubuntu.com-20120622123957-hbzwg84nt9rqwg8r
Tags: 2012.2~f2~20120621.14517-0ubuntu1
[ Chuck Short ]
* New upstream version.

[ Adam Gandelman ]
* debian/rules: Temporarily disable test suite while blocking
  tests are investigated. 
* debian/patches/kombu_tests_timeout.patch: Dropped.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_db_api.py
24
24
from nova import db
25
25
from nova import exception
26
26
from nova import flags
 
27
from nova.openstack.common import timeutils
27
28
from nova import test
28
29
from nova import utils
29
30
 
70
71
        inst1 = db.instance_create(self.context, args1)
71
72
        args2 = {'reservation_id': 'b', 'image_ref': 1, 'host': 'host1'}
72
73
        inst2 = db.instance_create(self.context, args2)
73
 
        db.instance_destroy(self.context.elevated(), inst1['id'])
 
74
        db.instance_destroy(self.context.elevated(), inst1['uuid'])
74
75
        result = db.instance_get_all_by_filters(self.context.elevated(), {})
75
76
        self.assertEqual(2, len(result))
76
77
        self.assertIn(inst1.id, [result[0].id, result[1].id])
96
97
        db.migration_update(ctxt, migration.id, {"status": "CONFIRMED"})
97
98
 
98
99
        # Ensure the new migration is not returned.
99
 
        updated_at = utils.utcnow()
 
100
        updated_at = timeutils.utcnow()
100
101
        values = {"status": "finished", "updated_at": updated_at}
101
102
        migration = db.migration_create(ctxt, values)
102
103
        results = db.migration_get_all_unconfirmed(ctxt, 10)
117
118
        instance = db.instance_create(ctxt, values)
118
119
        results = db.instance_get_all_hung_in_rebooting(ctxt, 10)
119
120
        self.assertEqual(1, len(results))
120
 
        db.instance_update(ctxt, instance.id, {"task_state": None})
 
121
        db.instance_update(ctxt, instance['uuid'], {"task_state": None})
121
122
 
122
123
        # Ensure the newly rebooted instance is not returned.
123
 
        updated_at = utils.utcnow()
 
124
        updated_at = timeutils.utcnow()
124
125
        values = {"task_state": "rebooting", "updated_at": updated_at}
125
126
        instance = db.instance_create(ctxt, values)
126
127
        results = db.instance_get_all_hung_in_rebooting(ctxt, 10)
127
128
        self.assertEqual(0, len(results))
128
 
        db.instance_update(ctxt, instance.id, {"task_state": None})
 
129
        db.instance_update(ctxt, instance['uuid'], {"task_state": None})
129
130
 
130
131
    def test_network_create_safe(self):
131
132
        ctxt = context.get_admin_context()
177
178
        # Update the metadata
178
179
        values = {'metadata': {'host': 'bar'},
179
180
                  'system_metadata': {'original_image_ref': 'baz'}}
180
 
        db.instance_update(ctxt, instance.id, values)
 
181
        db.instance_update(ctxt, instance['uuid'], values)
181
182
 
182
183
        # Retrieve the user-provided metadata to ensure it was successfully
183
184
        # updated
184
 
        instance_meta = db.instance_metadata_get(ctxt, instance.id)
 
185
        instance_meta = db.instance_metadata_get(ctxt, instance.uuid)
185
186
        self.assertEqual('bar', instance_meta['host'])
186
187
 
187
188
        # Retrieve the system metadata to ensure it was successfully updated
200
201
        # Update the metadata
201
202
        values = {'metadata': {'host': 'bar'},
202
203
                  'system_metadata': {'original_image_ref': 'baz'}}
203
 
        db.instance_update(ctxt, instance.uuid, values)
 
204
        db.instance_update(ctxt, instance['uuid'], values)
204
205
 
205
206
        # Retrieve the user-provided metadata to ensure it was successfully
206
207
        # updated
207
 
        instance_meta = db.instance_metadata_get(ctxt, instance.id)
 
208
        instance_meta = db.instance_metadata_get(ctxt, instance.uuid)
208
209
        self.assertEqual('bar', instance_meta['host'])
209
210
 
210
211
        # Retrieve the system metadata to ensure it was successfully updated
219
220
        instance = db.instance_create(ctxt, values)
220
221
 
221
222
        (old_ref, new_ref) = db.instance_update_and_get_original(ctxt,
222
 
                instance['id'], {'vm_state': 'needscoffee'})
 
223
                instance['uuid'], {'vm_state': 'needscoffee'})
223
224
        self.assertEquals("building", old_ref["vm_state"])
224
225
        self.assertEquals("needscoffee", new_ref["vm_state"])
225
226
 
383
384
        db.fixed_ip_create(ctxt, values)
384
385
 
385
386
    def test_fixed_ip_disassociate_all_by_timeout_single_host(self):
386
 
        now = utils.utcnow()
 
387
        now = timeutils.utcnow()
387
388
        ctxt = context.get_admin_context()
388
389
        self._timeout_test(ctxt, now, False)
389
390
        result = db.fixed_ip_disassociate_all_by_timeout(ctxt, 'foo', now)
392
393
        self.assertEqual(result, 1)
393
394
 
394
395
    def test_fixed_ip_disassociate_all_by_timeout_multi_host(self):
395
 
        now = utils.utcnow()
 
396
        now = timeutils.utcnow()
396
397
        ctxt = context.get_admin_context()
397
398
        self._timeout_test(ctxt, now, True)
398
399
        result = db.fixed_ip_disassociate_all_by_timeout(ctxt, 'foo', now)
840
841
        fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address)
841
842
        self.assertEqual(fixed_ip.instance_id, self.instance.id)
842
843
        self.assertEqual(fixed_ip.network_id, self.network.id)
 
844
 
 
845
 
 
846
class InstanceDestroyConstraints(test.TestCase):
 
847
 
 
848
    def test_destroy_with_equal_any_constraint_met(self):
 
849
        ctx = context.get_admin_context()
 
850
        instance = db.instance_create(ctx, {'task_state': 'deleting'})
 
851
        constraint = db.constraint(task_state=db.equal_any('deleting'))
 
852
        db.instance_destroy(ctx, instance['uuid'], constraint)
 
853
        self.assertRaises(exception.InstanceNotFound, db.instance_get_by_uuid,
 
854
                          ctx, instance['uuid'])
 
855
 
 
856
    def test_destroy_with_equal_any_constraint_not_met(self):
 
857
        ctx = context.get_admin_context()
 
858
        instance = db.instance_create(ctx, {'vm_state': 'resize'})
 
859
        constraint = db.constraint(vm_state=db.equal_any('active', 'error'))
 
860
        self.assertRaises(exception.ConstraintNotMet, db.instance_destroy,
 
861
                          ctx, instance['uuid'], constraint)
 
862
        instance = db.instance_get_by_uuid(ctx, instance['uuid'])
 
863
        self.assertFalse(instance['deleted'])
 
864
 
 
865
    def test_destroy_with_not_equal_constraint_met(self):
 
866
        ctx = context.get_admin_context()
 
867
        instance = db.instance_create(ctx, {'task_state': 'deleting'})
 
868
        constraint = db.constraint(task_state=db.not_equal('error', 'resize'))
 
869
        db.instance_destroy(ctx, instance['uuid'], constraint)
 
870
        self.assertRaises(exception.InstanceNotFound, db.instance_get_by_uuid,
 
871
                          ctx, instance['uuid'])
 
872
 
 
873
    def test_destroy_with_not_equal_constraint_not_met(self):
 
874
        ctx = context.get_admin_context()
 
875
        instance = db.instance_create(ctx, {'vm_state': 'active'})
 
876
        constraint = db.constraint(vm_state=db.not_equal('active', 'error'))
 
877
        self.assertRaises(exception.ConstraintNotMet, db.instance_destroy,
 
878
                          ctx, instance['uuid'], constraint)
 
879
        instance = db.instance_get_by_uuid(ctx, instance['uuid'])
 
880
        self.assertFalse(instance['deleted'])
 
881
 
 
882
 
 
883
def _get_sm_backend_params():
 
884
    config_params = ("name_label=testsmbackend "
 
885
                     "server=localhost "
 
886
                     "serverpath=/tmp/nfspath")
 
887
    params = dict(flavor_id=1,
 
888
                sr_uuid=None,
 
889
                sr_type='nfs',
 
890
                config_params=config_params)
 
891
    return params
 
892
 
 
893
 
 
894
def _get_sm_flavor_params():
 
895
    params = dict(label="gold",
 
896
                  description="automatic backups")
 
897
    return params
 
898
 
 
899
 
 
900
class SMVolumeDBApiTestCase(test.TestCase):
 
901
    def setUp(self):
 
902
        super(SMVolumeDBApiTestCase, self).setUp()
 
903
        self.user_id = 'fake'
 
904
        self.project_id = 'fake'
 
905
        self.context = context.RequestContext(self.user_id, self.project_id)
 
906
 
 
907
    def test_sm_backend_conf_create(self):
 
908
        params = _get_sm_backend_params()
 
909
        ctxt = context.get_admin_context()
 
910
        beconf = db.sm_backend_conf_create(ctxt,
 
911
                                           params)
 
912
        self.assertIsInstance(beconf['id'], int)
 
913
 
 
914
    def test_sm_backend_conf_create_raise_duplicate(self):
 
915
        params = _get_sm_backend_params()
 
916
        ctxt = context.get_admin_context()
 
917
        beconf = db.sm_backend_conf_create(ctxt,
 
918
                                           params)
 
919
        self.assertIsInstance(beconf['id'], int)
 
920
        self.assertRaises(exception.Duplicate,
 
921
                          db.sm_backend_conf_create,
 
922
                          ctxt,
 
923
                          params)
 
924
 
 
925
    def test_sm_backend_conf_update(self):
 
926
        ctxt = context.get_admin_context()
 
927
        params = _get_sm_backend_params()
 
928
        beconf = db.sm_backend_conf_create(ctxt,
 
929
                                           params)
 
930
        beconf = db.sm_backend_conf_update(ctxt,
 
931
                                           beconf['id'],
 
932
                                           dict(sr_uuid="FA15E-1D"))
 
933
        self.assertEqual(beconf['sr_uuid'], "FA15E-1D")
 
934
 
 
935
    def test_sm_backend_conf_update_raise_notfound(self):
 
936
        ctxt = context.get_admin_context()
 
937
        self.assertRaises(exception.NotFound,
 
938
                          db.sm_backend_conf_update,
 
939
                          ctxt,
 
940
                          7,
 
941
                          dict(sr_uuid="FA15E-1D"))
 
942
 
 
943
    def test_sm_backend_conf_get(self):
 
944
        ctxt = context.get_admin_context()
 
945
        params = _get_sm_backend_params()
 
946
        beconf = db.sm_backend_conf_create(ctxt,
 
947
                                           params)
 
948
        val = db.sm_backend_conf_get(ctxt, beconf['id'])
 
949
        self.assertDictMatch(dict(val), dict(beconf))
 
950
 
 
951
    def test_sm_backend_conf_get_raise_notfound(self):
 
952
        ctxt = context.get_admin_context()
 
953
        self.assertRaises(exception.NotFound,
 
954
                          db.sm_backend_conf_get,
 
955
                          ctxt,
 
956
                          7)
 
957
 
 
958
    def test_sm_backend_conf_get_by_sr(self):
 
959
        ctxt = context.get_admin_context()
 
960
        params = _get_sm_backend_params()
 
961
        beconf = db.sm_backend_conf_create(ctxt,
 
962
                                           params)
 
963
        val = db.sm_backend_conf_get_by_sr(ctxt, beconf['sr_uuid'])
 
964
        self.assertDictMatch(dict(val), dict(beconf))
 
965
 
 
966
    def test_sm_backend_conf_get_by_sr_raise_notfound(self):
 
967
        ctxt = context.get_admin_context()
 
968
        self.assertRaises(exception.NotFound,
 
969
                          db.sm_backend_conf_get_by_sr,
 
970
                          ctxt,
 
971
                          "FA15E-1D")
 
972
 
 
973
    def test_sm_backend_conf_delete(self):
 
974
        ctxt = context.get_admin_context()
 
975
        params = _get_sm_backend_params()
 
976
        beconf = db.sm_backend_conf_create(ctxt,
 
977
                                           params)
 
978
        db.sm_backend_conf_delete(ctxt, beconf['id'])
 
979
        self.assertRaises(exception.NotFound,
 
980
                          db.sm_backend_conf_get,
 
981
                          ctxt,
 
982
                          beconf['id'])
 
983
 
 
984
    def test_sm_backend_conf_delete_nonexisting(self):
 
985
        ctxt = context.get_admin_context()
 
986
        self.assertNotRaises(None, db.sm_backend_conf_delete,
 
987
                              ctxt, "FA15E-1D")
 
988
 
 
989
    def test_sm_flavor_create(self):
 
990
        ctxt = context.get_admin_context()
 
991
        params = _get_sm_flavor_params()
 
992
        flav = db.sm_flavor_create(ctxt,
 
993
                                   params)
 
994
        self.assertIsInstance(flav['id'], int)
 
995
 
 
996
    def sm_flavor_create_raise_duplicate(self):
 
997
        ctxt = context.get_admin_context()
 
998
        params = _get_sm_flavor_params()
 
999
        flav = db.sm_flavor_create(ctxt,
 
1000
                                   params)
 
1001
        self.assertRaises(exception.Duplicate,
 
1002
                          db.sm_flavor_create,
 
1003
                          params)
 
1004
 
 
1005
    def test_sm_flavor_update(self):
 
1006
        ctxt = context.get_admin_context()
 
1007
        params = _get_sm_flavor_params()
 
1008
        flav = db.sm_flavor_create(ctxt,
 
1009
                                   params)
 
1010
        newparms = dict(description="basic volumes")
 
1011
        flav = db.sm_flavor_update(ctxt, flav['id'], newparms)
 
1012
        self.assertEqual(flav['description'], "basic volumes")
 
1013
 
 
1014
    def test_sm_flavor_update_raise_notfound(self):
 
1015
        ctxt = context.get_admin_context()
 
1016
        self.assertRaises(exception.NotFound,
 
1017
                          db.sm_flavor_update,
 
1018
                          ctxt,
 
1019
                          7,
 
1020
                          dict(description="fakedesc"))
 
1021
 
 
1022
    def test_sm_flavor_delete(self):
 
1023
        ctxt = context.get_admin_context()
 
1024
        params = _get_sm_flavor_params()
 
1025
        flav = db.sm_flavor_create(ctxt,
 
1026
                                   params)
 
1027
        db.sm_flavor_delete(ctxt, flav['id'])
 
1028
        self.assertRaises(exception.NotFound,
 
1029
                          db.sm_flavor_get,
 
1030
                          ctxt,
 
1031
                          "gold")
 
1032
 
 
1033
    def test_sm_flavor_delete_nonexisting(self):
 
1034
        ctxt = context.get_admin_context()
 
1035
        self.assertNotRaises(None, db.sm_flavor_delete,
 
1036
                             ctxt, 7)
 
1037
 
 
1038
    def test_sm_flavor_get(self):
 
1039
        ctxt = context.get_admin_context()
 
1040
        params = _get_sm_flavor_params()
 
1041
        flav = db.sm_flavor_create(ctxt,
 
1042
                                   params)
 
1043
        val = db.sm_flavor_get(ctxt, flav['id'])
 
1044
        self.assertDictMatch(dict(val), dict(flav))
 
1045
 
 
1046
    def test_sm_flavor_get_raise_notfound(self):
 
1047
        ctxt = context.get_admin_context()
 
1048
        self.assertRaises(exception.NotFound,
 
1049
                          db.sm_flavor_get,
 
1050
                          ctxt,
 
1051
                          7)
 
1052
 
 
1053
    def test_sm_flavor_get_by_label(self):
 
1054
        ctxt = context.get_admin_context()
 
1055
        params = _get_sm_flavor_params()
 
1056
        flav = db.sm_flavor_create(ctxt,
 
1057
                                   params)
 
1058
        val = db.sm_flavor_get_by_label(ctxt, flav['label'])
 
1059
        self.assertDictMatch(dict(val), dict(flav))
 
1060
 
 
1061
    def test_sm_flavor_get_by_label_raise_notfound(self):
 
1062
        ctxt = context.get_admin_context()
 
1063
        self.assertRaises(exception.NotFound,
 
1064
                          db.sm_flavor_get,
 
1065
                          ctxt,
 
1066
                          "fake")