← Back to branch summary

~rlane/nova/lp773690

« back to all changes in this revision

Viewing changes to nova/tests/test_scheduler.py

  • Committer: rlane at wikimedia
  • Date: 2011-04-29 22:30:40 UTC
  • mfrom: (382.1.655 nova)
  • Revision ID: rlane@wikimedia.org-20110429223040-i0x3ds9eqwrabyru
Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_scheduler.py
120
120
        dest = 'dummydest'
121
121
        ctxt = context.get_admin_context()
122
122
 
123
 
        try:
124
 
            scheduler.show_host_resources(ctxt, dest)
125
 
        except exception.NotFound, e:
126
 
            c1 = (e.message.find(_("does not exist or is not a "
127
 
                                   "compute node.")) >= 0)
128
 
        self.assertTrue(c1)
 
123
        self.assertRaises(exception.NotFound, scheduler.show_host_resources,
 
124
                          ctxt, dest)
 
125
        #TODO(bcwaldon): reimplement this functionality
 
126
        #c1 = (e.message.find(_("does not exist or is not a "
 
127
        #                       "compute node.")) >= 0)
129
128
 
130
129
    def _dic_is_equal(self, dic1, dic2, keys=None):
131
130
        """Compares 2 dictionary contents(Helper method)"""
698
697
               'topic': 'volume', 'report_count': 0}
699
698
        s_ref = db.service_create(self.context, dic)
700
699
 
701
 
        try:
702
 
            self.scheduler.driver.schedule_live_migration(self.context,
703
 
                                                          instance_id,
704
 
                                                          i_ref['host'])
705
 
        except exception.Invalid, e:
706
 
            c = (e.message.find('volume node is not alive') >= 0)
 
700
        self.assertRaises(exception.VolumeServiceUnavailable,
 
701
                          self.scheduler.driver.schedule_live_migration,
 
702
                          self.context, instance_id, i_ref['host'])
707
703
 
708
 
        self.assertTrue(c)
709
704
        db.instance_destroy(self.context, instance_id)
710
705
        db.service_destroy(self.context, s_ref['id'])
711
706
        db.volume_destroy(self.context, v_ref['id'])
718
713
        s_ref = self._create_compute_service(created_at=t, updated_at=t,
719
714
                                             host=i_ref['host'])
720
715
 
721
 
        try:
722
 
            self.scheduler.driver._live_migration_src_check(self.context,
723
 
                                                            i_ref)
724
 
        except exception.Invalid, e:
725
 
            c = (e.message.find('is not alive') >= 0)
 
716
        self.assertRaises(exception.ComputeServiceUnavailable,
 
717
                          self.scheduler.driver._live_migration_src_check,
 
718
                          self.context, i_ref)
726
719
 
727
 
        self.assertTrue(c)
728
720
        db.instance_destroy(self.context, instance_id)
729
721
        db.service_destroy(self.context, s_ref['id'])
730
722
 
737
729
        ret = self.scheduler.driver._live_migration_src_check(self.context,
738
730
                                                              i_ref)
739
731
 
740
 
        self.assertTrue(ret == None)
 
732
        self.assertTrue(ret is None)
741
733
        db.instance_destroy(self.context, instance_id)
742
734
        db.service_destroy(self.context, s_ref['id'])
743
735
 
749
741
        s_ref = self._create_compute_service(created_at=t, updated_at=t,
750
742
                                             host=i_ref['host'])
751
743
 
752
 
        try:
753
 
            self.scheduler.driver._live_migration_dest_check(self.context,
754
 
                                                             i_ref,
755
 
                                                             i_ref['host'])
756
 
        except exception.Invalid, e:
757
 
            c = (e.message.find('is not alive') >= 0)
 
744
        self.assertRaises(exception.ComputeServiceUnavailable,
 
745
                          self.scheduler.driver._live_migration_dest_check,
 
746
                          self.context, i_ref, i_ref['host'])
758
747
 
759
 
        self.assertTrue(c)
760
748
        db.instance_destroy(self.context, instance_id)
761
749
        db.service_destroy(self.context, s_ref['id'])
762
750
 
766
754
        i_ref = db.instance_get(self.context, instance_id)
767
755
        s_ref = self._create_compute_service(host=i_ref['host'])
768
756
 
769
 
        try:
770
 
            self.scheduler.driver._live_migration_dest_check(self.context,
771
 
                                                             i_ref,
772
 
                                                             i_ref['host'])
773
 
        except exception.Invalid, e:
774
 
            c = (e.message.find('choose other host') >= 0)
 
757
        self.assertRaises(exception.UnableToMigrateToSelf,
 
758
                          self.scheduler.driver._live_migration_dest_check,
 
759
                          self.context, i_ref, i_ref['host'])
775
760
 
776
 
        self.assertTrue(c)
777
761
        db.instance_destroy(self.context, instance_id)
778
762
        db.service_destroy(self.context, s_ref['id'])
779
763
 
805
789
        ret = self.scheduler.driver._live_migration_dest_check(self.context,
806
790
                                                             i_ref,
807
791
                                                             'somewhere')
808
 
        self.assertTrue(ret == None)
 
792
        self.assertTrue(ret is None)
809
793
        db.instance_destroy(self.context, instance_id)
810
794
        db.service_destroy(self.context, s_ref['id'])
811
795
 
837
821
             "args": {'filename': fpath}})
838
822
 
839
823
        self.mox.ReplayAll()
840
 
        try:
841
 
            self.scheduler.driver._live_migration_common_check(self.context,
842
 
                                                               i_ref,
843
 
                                                               dest)
844
 
        except exception.Invalid, e:
845
 
            c = (e.message.find('does not exist') >= 0)
 
824
        self.assertRaises(exception.SourceHostUnavailable,
 
825
                          self.scheduler.driver._live_migration_common_check,
 
826
                          self.context, i_ref, dest)
846
827
 
847
 
        self.assertTrue(c)
848
828
        db.instance_destroy(self.context, instance_id)
849
829
        db.service_destroy(self.context, s_ref['id'])
850
830
 
865
845
        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
866
846
 
867
847
        self.mox.ReplayAll()
868
 
        try:
869
 
            self.scheduler.driver._live_migration_common_check(self.context,
870
 
                                                               i_ref,
871
 
                                                               dest)
872
 
        except exception.Invalid, e:
873
 
            c = (e.message.find(_('Different hypervisor type')) >= 0)
 
848
        self.assertRaises(exception.InvalidHypervisorType,
 
849
                          self.scheduler.driver._live_migration_common_check,
 
850
                          self.context, i_ref, dest)
874
851
 
875
 
        self.assertTrue(c)
876
852
        db.instance_destroy(self.context, instance_id)
877
853
        db.service_destroy(self.context, s_ref['id'])
878
854
        db.service_destroy(self.context, s_ref2['id'])
895
871
        driver.mounted_on_same_shared_storage(mox.IgnoreArg(), i_ref, dest)
896
872
 
897
873
        self.mox.ReplayAll()
898
 
        try:
899
 
            self.scheduler.driver._live_migration_common_check(self.context,
900
 
                                                               i_ref,
901
 
                                                               dest)
902
 
        except exception.Invalid, e:
903
 
            c = (e.message.find(_('Older hypervisor version')) >= 0)
 
874
        self.assertRaises(exception.DestinationHypervisorTooOld,
 
875
                          self.scheduler.driver._live_migration_common_check,
 
876
                          self.context, i_ref, dest)
904
877
 
905
 
        self.assertTrue(c)
906
878
        db.instance_destroy(self.context, instance_id)
907
879
        db.service_destroy(self.context, s_ref['id'])
908
880
        db.service_destroy(self.context, s_ref2['id'])
968
940
 
969
941
 
970
942
def go_boom(self, context, instance):
971
 
    raise exception.InstanceNotFound("boom message", instance)
 
943
    raise exception.InstanceNotFound(instance_id=instance)
972
944
 
973
945
 
974
946
def found_instance(self, context, instance):
1017
989
    def test_routing_flags(self):
1018
990
        FLAGS.enable_zone_routing = False
1019
991
        decorator = FakeRerouteCompute("foo")
1020
 
        try:
1021
 
            result = decorator(go_boom)(None, None, 1)
1022
 
            self.assertFail(_("Should have thrown exception."))
1023
 
        except exception.InstanceNotFound, e:
1024
 
            self.assertEquals(e.message, 'boom message')
 
992
        self.assertRaises(exception.InstanceNotFound, decorator(go_boom),
 
993
                          None, None, 1)
1025
994
 
1026
995
    def test_get_collection_context_and_id(self):
1027
996
        decorator = api.reroute_compute("foo")