← Back to branch summary

~cerberus/nova/disk_config

« back to all changes in this revision

Viewing changes to nova/tests/test_compute.py

  • Committer: matt.dietz at rackspace
  • Date: 2011-09-21 19:48:25 UTC
  • mfrom: (1511.1.98 nova)
  • Revision ID: matt.dietz@rackspace.com-20110921194825-zv1w4qonfh6o1j2u
Merge from trunk, updated failing tests and pep8

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/test_compute.py
21
21
"""
22
22
 
23
23
from nova import compute
24
 
from nova.compute import instance_types
25
 
from nova.compute import manager as compute_manager
26
 
from nova.compute import power_state
27
 
from nova.compute import vm_states
28
24
from nova import context
29
25
from nova import db
30
 
from nova.db.sqlalchemy import models
31
 
from nova.db.sqlalchemy import api as sqlalchemy_api
32
26
from nova import exception
33
27
from nova import flags
34
 
import nova.image.fake
35
28
from nova import log as logging
36
29
from nova import rpc
37
30
from nova import test
38
31
from nova import utils
 
32
 
 
33
from nova.compute import instance_types
 
34
from nova.compute import manager as compute_manager
 
35
from nova.compute import power_state
 
36
from nova.compute import vm_states
 
37
from nova.db.sqlalchemy import models
 
38
from nova.image import fake as fake_image
39
39
from nova.notifier import test_notifier
 
40
from nova.tests import fake_network
 
41
 
40
42
 
41
43
LOG = logging.getLogger('nova.tests.compute')
42
44
FLAGS = flags.FLAGS
74
76
        def fake_show(meh, context, id):
75
77
            return {'id': 1, 'properties': {'kernel_id': 1, 'ramdisk_id': 1}}
76
78
 
77
 
        self.stubs.Set(nova.image.fake._FakeImageService, 'show', fake_show)
 
79
        self.stubs.Set(fake_image._FakeImageService, 'show', fake_show)
78
80
 
79
81
    def _create_instance(self, params=None):
80
82
        """Create a test instance"""
1023
1025
        db.instance_destroy(c, instance_id2)
1024
1026
        db.instance_destroy(c, instance_id3)
1025
1027
 
1026
 
    def test_get_by_fixed_ip(self):
1027
 
        """Test getting 1 instance by Fixed IP"""
1028
 
        c = context.get_admin_context()
1029
 
        instance_id1 = self._create_instance()
1030
 
        instance_id2 = self._create_instance({'id': 20})
1031
 
        instance_id3 = self._create_instance({'id': 30})
1032
 
 
1033
 
        vif_ref1 = db.virtual_interface_create(c,
1034
 
                {'address': '12:34:56:78:90:12',
1035
 
                 'instance_id': instance_id1,
1036
 
                 'network_id': 1})
1037
 
        vif_ref2 = db.virtual_interface_create(c,
1038
 
                {'address': '90:12:34:56:78:90',
1039
 
                 'instance_id': instance_id2,
1040
 
                 'network_id': 1})
1041
 
 
1042
 
        db.fixed_ip_create(c,
1043
 
                {'address': '1.1.1.1',
1044
 
                 'instance_id': instance_id1,
1045
 
                 'virtual_interface_id': vif_ref1['id']})
1046
 
        db.fixed_ip_create(c,
1047
 
                {'address': '1.1.2.1',
1048
 
                 'instance_id': instance_id2,
1049
 
                 'virtual_interface_id': vif_ref2['id']})
1050
 
 
1051
 
        # regex not allowed
1052
 
        instances = self.compute_api.get_all(c,
1053
 
                search_opts={'fixed_ip': '.*'})
1054
 
        self.assertEqual(len(instances), 0)
1055
 
 
1056
 
        instances = self.compute_api.get_all(c,
1057
 
                search_opts={'fixed_ip': '1.1.3.1'})
1058
 
        self.assertEqual(len(instances), 0)
1059
 
 
1060
 
        instances = self.compute_api.get_all(c,
1061
 
                search_opts={'fixed_ip': '1.1.1.1'})
1062
 
        self.assertEqual(len(instances), 1)
1063
 
        self.assertEqual(instances[0].id, instance_id1)
1064
 
 
1065
 
        instances = self.compute_api.get_all(c,
1066
 
                search_opts={'fixed_ip': '1.1.2.1'})
1067
 
        self.assertEqual(len(instances), 1)
1068
 
        self.assertEqual(instances[0].id, instance_id2)
1069
 
 
1070
 
        db.virtual_interface_delete(c, vif_ref1['id'])
1071
 
        db.virtual_interface_delete(c, vif_ref2['id'])
1072
 
        db.instance_destroy(c, instance_id1)
1073
 
        db.instance_destroy(c, instance_id2)
1074
 
 
1075
 
    def test_get_all_by_ip_regexp(self):
1076
 
        """Test searching by Floating and Fixed IP"""
1077
 
        c = context.get_admin_context()
1078
 
        instance_id1 = self._create_instance({'display_name': 'woot'})
1079
 
        instance_id2 = self._create_instance({
1080
 
                'display_name': 'woo',
1081
 
                'id': 20})
1082
 
        instance_id3 = self._create_instance({
1083
 
                'display_name': 'not-woot',
1084
 
                'id': 30})
1085
 
 
1086
 
        vif_ref1 = db.virtual_interface_create(c,
1087
 
                {'address': '12:34:56:78:90:12',
1088
 
                 'instance_id': instance_id1,
1089
 
                 'network_id': 1})
1090
 
        vif_ref2 = db.virtual_interface_create(c,
1091
 
                {'address': '90:12:34:56:78:90',
1092
 
                 'instance_id': instance_id2,
1093
 
                 'network_id': 1})
1094
 
        vif_ref3 = db.virtual_interface_create(c,
1095
 
                {'address': '34:56:78:90:12:34',
1096
 
                 'instance_id': instance_id3,
1097
 
                 'network_id': 1})
1098
 
 
1099
 
        db.fixed_ip_create(c,
1100
 
                {'address': '1.1.1.1',
1101
 
                 'instance_id': instance_id1,
1102
 
                 'virtual_interface_id': vif_ref1['id']})
1103
 
        db.fixed_ip_create(c,
1104
 
                {'address': '1.1.2.1',
1105
 
                 'instance_id': instance_id2,
1106
 
                 'virtual_interface_id': vif_ref2['id']})
1107
 
        fix_addr = db.fixed_ip_create(c,
1108
 
                {'address': '1.1.3.1',
1109
 
                 'instance_id': instance_id3,
1110
 
                 'virtual_interface_id': vif_ref3['id']})
1111
 
        fix_ref = db.fixed_ip_get_by_address(c, fix_addr)
1112
 
        flo_ref = db.floating_ip_create(c,
1113
 
                {'address': '10.0.0.2',
1114
 
                'fixed_ip_id': fix_ref['id']})
1115
 
 
1116
 
        # ends up matching 2nd octet here.. so all 3 match
1117
 
        instances = self.compute_api.get_all(c,
1118
 
                search_opts={'ip': '.*\.1'})
1119
 
        self.assertEqual(len(instances), 3)
1120
 
 
1121
 
        instances = self.compute_api.get_all(c,
1122
 
                search_opts={'ip': '1.*'})
1123
 
        self.assertEqual(len(instances), 3)
1124
 
 
1125
 
        instances = self.compute_api.get_all(c,
1126
 
                search_opts={'ip': '.*\.1.\d+$'})
1127
 
        self.assertEqual(len(instances), 1)
1128
 
        instance_ids = [instance.id for instance in instances]
1129
 
        self.assertTrue(instance_id1 in instance_ids)
1130
 
 
1131
 
        instances = self.compute_api.get_all(c,
1132
 
                search_opts={'ip': '.*\.2.+'})
1133
 
        self.assertEqual(len(instances), 1)
1134
 
        self.assertEqual(instances[0].id, instance_id2)
1135
 
 
1136
 
        instances = self.compute_api.get_all(c,
1137
 
                search_opts={'ip': '10.*'})
1138
 
        self.assertEqual(len(instances), 1)
1139
 
        self.assertEqual(instances[0].id, instance_id3)
1140
 
 
1141
 
        db.virtual_interface_delete(c, vif_ref1['id'])
1142
 
        db.virtual_interface_delete(c, vif_ref2['id'])
1143
 
        db.virtual_interface_delete(c, vif_ref3['id'])
1144
 
        db.floating_ip_destroy(c, '10.0.0.2')
1145
 
        db.instance_destroy(c, instance_id1)
1146
 
        db.instance_destroy(c, instance_id2)
1147
 
        db.instance_destroy(c, instance_id3)
1148
 
 
1149
 
    def test_get_all_by_ipv6_regexp(self):
1150
 
        """Test searching by IPv6 address"""
1151
 
 
1152
 
        c = context.get_admin_context()
1153
 
        instance_id1 = self._create_instance({'display_name': 'woot'})
1154
 
        instance_id2 = self._create_instance({
1155
 
                'display_name': 'woo',
1156
 
                'id': 20})
1157
 
        instance_id3 = self._create_instance({
1158
 
                'display_name': 'not-woot',
1159
 
                'id': 30})
1160
 
 
1161
 
        vif_ref1 = db.virtual_interface_create(c,
1162
 
                {'address': '12:34:56:78:90:12',
1163
 
                 'instance_id': instance_id1,
1164
 
                 'network_id': 1})
1165
 
        vif_ref2 = db.virtual_interface_create(c,
1166
 
                {'address': '90:12:34:56:78:90',
1167
 
                 'instance_id': instance_id2,
1168
 
                 'network_id': 1})
1169
 
        vif_ref3 = db.virtual_interface_create(c,
1170
 
                {'address': '34:56:78:90:12:34',
1171
 
                 'instance_id': instance_id3,
1172
 
                 'network_id': 1})
1173
 
 
1174
 
        # This will create IPv6 addresses of:
1175
 
        # 1: fd00::1034:56ff:fe78:9012
1176
 
        # 20: fd00::9212:34ff:fe56:7890
1177
 
        # 30: fd00::3656:78ff:fe90:1234
1178
 
 
1179
 
        instances = self.compute_api.get_all(c,
1180
 
                search_opts={'ip6': '.*1034.*'})
1181
 
        self.assertEqual(len(instances), 1)
1182
 
        self.assertEqual(instances[0].id, instance_id1)
1183
 
 
1184
 
        instances = self.compute_api.get_all(c,
1185
 
                search_opts={'ip6': '^fd00.*'})
1186
 
        self.assertEqual(len(instances), 3)
1187
 
        instance_ids = [instance.id for instance in instances]
1188
 
        self.assertTrue(instance_id1 in instance_ids)
1189
 
        self.assertTrue(instance_id2 in instance_ids)
1190
 
        self.assertTrue(instance_id3 in instance_ids)
1191
 
 
1192
 
        instances = self.compute_api.get_all(c,
1193
 
                search_opts={'ip6': '^.*12.*34.*'})
1194
 
        self.assertEqual(len(instances), 2)
1195
 
        instance_ids = [instance.id for instance in instances]
1196
 
        self.assertTrue(instance_id2 in instance_ids)
1197
 
        self.assertTrue(instance_id3 in instance_ids)
1198
 
 
1199
 
        db.virtual_interface_delete(c, vif_ref1['id'])
1200
 
        db.virtual_interface_delete(c, vif_ref2['id'])
1201
 
        db.virtual_interface_delete(c, vif_ref3['id'])
1202
 
        db.instance_destroy(c, instance_id1)
1203
 
        db.instance_destroy(c, instance_id2)
1204
 
        db.instance_destroy(c, instance_id3)
1205
 
 
1206
1028
    def test_get_all_by_multiple_options_at_once(self):
1207
1029
        """Test searching by multiple options at once"""
1208
1030
        c = context.get_admin_context()
1209
 
        instance_id1 = self._create_instance({'display_name': 'woot'})
 
1031
        network_manager = fake_network.FakeNetworkManager()
 
1032
        self.stubs.Set(self.compute_api.network_api,
 
1033
                       'get_instance_uuids_by_ip_filter',
 
1034
                       network_manager.get_instance_uuids_by_ip_filter)
 
1035
        self.stubs.Set(network_manager.db,
 
1036
                       'instance_get_id_to_uuid_mapping',
 
1037
                       db.instance_get_id_to_uuid_mapping)
 
1038
 
 
1039
        instance_id1 = self._create_instance({'display_name': 'woot',
 
1040
                                              'id': 0})
1210
1041
        instance_id2 = self._create_instance({
1211
1042
                'display_name': 'woo',
1212
1043
                'id': 20})
1214
1045
                'display_name': 'not-woot',
1215
1046
                'id': 30})
1216
1047
 
1217
 
        vif_ref1 = db.virtual_interface_create(c,
1218
 
                {'address': '12:34:56:78:90:12',
1219
 
                 'instance_id': instance_id1,
1220
 
                 'network_id': 1})
1221
 
        vif_ref2 = db.virtual_interface_create(c,
1222
 
                {'address': '90:12:34:56:78:90',
1223
 
                 'instance_id': instance_id2,
1224
 
                 'network_id': 1})
1225
 
        vif_ref3 = db.virtual_interface_create(c,
1226
 
                {'address': '34:56:78:90:12:34',
1227
 
                 'instance_id': instance_id3,
1228
 
                 'network_id': 1})
1229
 
 
1230
 
        db.fixed_ip_create(c,
1231
 
                {'address': '1.1.1.1',
1232
 
                 'instance_id': instance_id1,
1233
 
                 'virtual_interface_id': vif_ref1['id']})
1234
 
        db.fixed_ip_create(c,
1235
 
                {'address': '1.1.2.1',
1236
 
                 'instance_id': instance_id2,
1237
 
                 'virtual_interface_id': vif_ref2['id']})
1238
 
        fix_addr = db.fixed_ip_create(c,
1239
 
                {'address': '1.1.3.1',
1240
 
                 'instance_id': instance_id3,
1241
 
                 'virtual_interface_id': vif_ref3['id']})
1242
 
        fix_ref = db.fixed_ip_get_by_address(c, fix_addr)
1243
 
        flo_ref = db.floating_ip_create(c,
1244
 
                {'address': '10.0.0.2',
1245
 
                'fixed_ip_id': fix_ref['id']})
1246
 
 
1247
1048
        # ip ends up matching 2nd octet here.. so all 3 match ip
1248
1049
        # but 'name' only matches one
1249
1050
        instances = self.compute_api.get_all(c,
1251
1052
        self.assertEqual(len(instances), 1)
1252
1053
        self.assertEqual(instances[0].id, instance_id3)
1253
1054
 
1254
 
        # ip ends up matching any ip with a '2' in it.. so instance
1255
 
        # 2 and 3.. but name should only match #2
 
1055
        # ip ends up matching any ip with a '1' in the last octet..
 
1056
        # so instance 1 and 3.. but name should only match #1
1256
1057
        # but 'name' only matches one
1257
1058
        instances = self.compute_api.get_all(c,
1258
 
                search_opts={'ip': '.*2', 'name': '^woo.*'})
 
1059
                search_opts={'ip': '.*\.1$', 'name': '^woo.*'})
1259
1060
        self.assertEqual(len(instances), 1)
1260
 
        self.assertEqual(instances[0].id, instance_id2)
 
1061
        self.assertEqual(instances[0].id, instance_id1)
1261
1062
 
1262
1063
        # same as above but no match on name (name matches instance_id1
1263
1064
        # but the ip query doesn't
1264
1065
        instances = self.compute_api.get_all(c,
1265
 
                search_opts={'ip': '.*2.*', 'name': '^woot.*'})
 
1066
                search_opts={'ip': '.*\.2$', 'name': '^woot.*'})
1266
1067
        self.assertEqual(len(instances), 0)
1267
1068
 
1268
1069
        # ip matches all 3... ipv6 matches #2+#3...name matches #3
1273
1074
        self.assertEqual(len(instances), 1)
1274
1075
        self.assertEqual(instances[0].id, instance_id3)
1275
1076
 
1276
 
        db.virtual_interface_delete(c, vif_ref1['id'])
1277
 
        db.virtual_interface_delete(c, vif_ref2['id'])
1278
 
        db.virtual_interface_delete(c, vif_ref3['id'])
1279
 
        db.floating_ip_destroy(c, '10.0.0.2')
1280
1077
        db.instance_destroy(c, instance_id1)
1281
1078
        db.instance_destroy(c, instance_id2)
1282
1079
        db.instance_destroy(c, instance_id3)