← Back to branch summary

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

« back to all changes in this revision

Viewing changes to nova/tests/api/openstack/fakes.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-08-16 14:04:11 UTC
  • mto: This revision was merged to the branch mainline in revision 84.
  • Revision ID: package-import@ubuntu.com-20120816140411-0mr4n241wmk30t9l
Tags: upstream-2012.2~f3
Import upstream version 2012.2~f3

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/api/openstack/fakes.py
17
17
 
18
18
import datetime
19
19
 
20
 
from glance import client as glance_client
 
20
import glanceclient.v1.images
21
21
import routes
22
22
import webob
23
23
import webob.dec
31
31
from nova.api.openstack.compute import versions
32
32
from nova.api.openstack import urlmap
33
33
from nova.api.openstack import wsgi as os_wsgi
34
 
import nova.auth.manager as auth_manager
35
34
from nova.compute import instance_types
36
35
from nova.compute import vm_states
37
36
from nova import context
70
69
        return res
71
70
 
72
71
 
73
 
def fake_auth_init(self, application):
74
 
    self.db = FakeAuthDatabase()
75
 
    self.context = Context()
76
 
    self.auth = FakeAuthManager()
77
 
    self.application = application
78
 
 
79
 
 
80
72
@webob.dec.wsgify
81
73
def fake_wsgi(self, req):
82
74
    return self.application
137
129
        '__call__', fake_wsgi)
138
130
 
139
131
 
140
 
def stub_out_instance_quota(stubs, allowed):
 
132
def stub_out_instance_quota(stubs, allowed, quota, resource='instances'):
141
133
    def fake_reserve(context, **deltas):
142
 
        instances = deltas.pop('instances', 0)
143
 
        if instances > allowed:
144
 
            raise exc.OverQuota(overs=['instances'], quotas=dict(
145
 
                    instances=allowed,
146
 
                    cores=10000,
147
 
                    ram=10000 * 1024,
148
 
                    ), usages=dict(
149
 
                    instances=dict(in_use=0, reserved=0),
150
 
                    cores=dict(in_use=0, reserved=0),
151
 
                    ram=dict(in_use=0, reserved=0),
152
 
                    ))
 
134
        requested = deltas.pop(resource, 0)
 
135
        if requested > allowed:
 
136
            quotas = dict(instances=1, cores=1, ram=1)
 
137
            quotas[resource] = quota
 
138
            usages = dict(instances=dict(in_use=0, reserved=0),
 
139
                          cores=dict(in_use=0, reserved=0),
 
140
                          ram=dict(in_use=0, reserved=0))
 
141
            usages[resource]['in_use'] = (quotas[resource] * 0.9 -
 
142
                                          allowed)
 
143
            usages[resource]['reserved'] = quotas[resource] * 0.1
 
144
            raise exc.OverQuota(overs=[resource], quotas=quotas,
 
145
                                usages=usages)
153
146
    stubs.Set(QUOTAS, 'reserve', fake_reserve)
154
147
 
155
148
 
252
245
    return fixtures
253
246
 
254
247
 
255
 
def stub_out_glance_add_image(stubs, sent_to_glance):
 
248
def stub_out_glanceclient_create(stubs, sent_to_glance):
256
249
    """
257
250
    We return the metadata sent to glance by modifying the sent_to_glance dict
258
251
    in place.
259
252
    """
260
 
    orig_add_image = glance_client.Client.add_image
 
253
    orig_add_image = glanceclient.v1.images.ImageManager.create
261
254
 
262
 
    def fake_add_image(context, metadata, data=None):
 
255
    def fake_create(context, metadata, data=None):
263
256
        sent_to_glance['metadata'] = metadata
264
257
        sent_to_glance['data'] = data
265
258
        return orig_add_image(metadata, data)
266
259
 
267
 
    stubs.Set(glance_client.Client, 'add_image', fake_add_image)
 
260
    stubs.Set(glanceclient.v1.images.ImageManager, 'create', fake_create)
268
261
 
269
262
 
270
263
def stub_out_glance(stubs):
271
264
    def fake_get_remote_image_service():
272
265
        client = glance_stubs.StubGlanceClient(_make_image_fixtures())
273
 
        return nova.image.glance.GlanceImageService(client)
 
266
        client_wrapper = nova.image.glance.GlanceClientWrapper()
 
267
        client_wrapper.host = 'fake_host'
 
268
        client_wrapper.port = 9292
 
269
        client_wrapper.client = client
 
270
        return nova.image.glance.GlanceImageService(client=client_wrapper)
274
271
    stubs.Set(nova.image.glance,
275
272
              'get_default_image_service',
276
273
              fake_get_remote_image_service)
337
334
            del FakeAuthDatabase.data['id_%i' % token_id]
338
335
 
339
336
 
340
 
class FakeAuthManager(object):
341
 
    #NOTE(justinsb): Accessing static variables through instances is FUBAR
342
 
    #NOTE(justinsb): This should also be private!
343
 
    auth_data = []
344
 
    projects = {}
345
 
 
346
 
    @classmethod
347
 
    def clear_fakes(cls):
348
 
        cls.auth_data = []
349
 
        cls.projects = {}
350
 
 
351
 
    @classmethod
352
 
    def reset_fake_data(cls):
353
 
        u1 = auth_manager.User('id1', 'guy1', 'acc1', 'secret1', False)
354
 
        cls.auth_data = [u1]
355
 
        cls.projects = dict(testacct=auth_manager.Project('testacct',
356
 
                                             'testacct',
357
 
                                             'id1',
358
 
                                             'test',
359
 
                                              []))
360
 
 
361
 
    def add_user(self, user):
362
 
        FakeAuthManager.auth_data.append(user)
363
 
 
364
 
    def get_users(self):
365
 
        return FakeAuthManager.auth_data
366
 
 
367
 
    def get_user(self, uid):
368
 
        for user in FakeAuthManager.auth_data:
369
 
            if user.id == uid:
370
 
                return user
371
 
        return None
372
 
 
373
 
    def get_user_from_access_key(self, key):
374
 
        for user in FakeAuthManager.auth_data:
375
 
            if user.access == key:
376
 
                return user
377
 
        return None
378
 
 
379
 
    def delete_user(self, uid):
380
 
        for user in FakeAuthManager.auth_data:
381
 
            if user.id == uid:
382
 
                FakeAuthManager.auth_data.remove(user)
383
 
        return None
384
 
 
385
 
    def create_user(self, name, access=None, secret=None, admin=False):
386
 
        u = auth_manager.User(name, name, access, secret, admin)
387
 
        FakeAuthManager.auth_data.append(u)
388
 
        return u
389
 
 
390
 
    def modify_user(self, user_id, access=None, secret=None, admin=None):
391
 
        user = self.get_user(user_id)
392
 
        if user:
393
 
            user.access = access
394
 
            user.secret = secret
395
 
            if admin is not None:
396
 
                user.admin = admin
397
 
 
398
 
    def is_admin(self, user_id):
399
 
        user = self.get_user(user_id)
400
 
        return user.admin
401
 
 
402
 
    def is_project_member(self, user_id, project):
403
 
        if not isinstance(project, auth_manager.Project):
404
 
            try:
405
 
                project = self.get_project(project)
406
 
            except exc.NotFound:
407
 
                raise webob.exc.HTTPUnauthorized()
408
 
        return ((user_id in project.member_ids) or
409
 
                (user_id == project.project_manager_id))
410
 
 
411
 
    def create_project(self, name, manager_user, description=None,
412
 
                       member_users=None):
413
 
        member_ids = ([auto_manager.User.safe_id(m) for m in member_users]
414
 
                      if member_users else [])
415
 
        p = auth_manager.Project(name, name,
416
 
                                 auth_manager.User.safe_id(manager_user),
417
 
                                 description, member_ids)
418
 
        FakeAuthManager.projects[name] = p
419
 
        return p
420
 
 
421
 
    def delete_project(self, pid):
422
 
        if pid in FakeAuthManager.projects:
423
 
            del FakeAuthManager.projects[pid]
424
 
 
425
 
    def modify_project(self, project, manager_user=None, description=None):
426
 
        p = FakeAuthManager.projects.get(project)
427
 
        p.project_manager_id = auth_manager.User.safe_id(manager_user)
428
 
        p.description = description
429
 
 
430
 
    def get_project(self, pid):
431
 
        p = FakeAuthManager.projects.get(pid)
432
 
        if p:
433
 
            return p
434
 
        else:
435
 
            raise exc.NotFound
436
 
 
437
 
    def get_projects(self, user_id=None):
438
 
        if not user_id:
439
 
            return FakeAuthManager.projects.values()
440
 
        else:
441
 
            return [p for p in FakeAuthManager.projects.values()
442
 
                    if (user_id in p.member_ids) or
443
 
                       (user_id == p.project_manager_id)]
444
 
 
445
 
 
446
337
class FakeRateLimiter(object):
447
338
    def __init__(self, application):
448
339
        self.application = application
507
398
                  flavor_id="1", name=None, key_name='',
508
399
                  access_ipv4=None, access_ipv6=None, progress=0,
509
400
                  auto_disk_config=False, display_name=None,
510
 
                  include_fake_metadata=True,
 
401
                  include_fake_metadata=True, config_drive=None,
511
402
                  power_state=None, nw_cache=None, metadata=None,
512
403
                  security_groups=None):
513
404
 
547
438
        "id": int(id),
548
439
        "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
549
440
        "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
550
 
        "admin_pass": "",
551
441
        "user_id": user_id,
552
442
        "project_id": project_id,
553
443
        "image_ref": image_ref,
556
446
        "launch_index": 0,
557
447
        "key_name": key_name,
558
448
        "key_data": key_data,
 
449
        "config_drive": config_drive,
559
450
        "vm_state": vm_state or vm_states.BUILDING,
560
451
        "task_state": task_state,
561
452
        "power_state": power_state,
608
499
        'name': 'vol name',
609
500
        'display_name': 'displayname',
610
501
        'display_description': 'displaydesc',
611
 
        'created_at': datetime.datetime(1, 1, 1, 1, 1, 1),
 
502
        'created_at': datetime.datetime(1999, 1, 1, 1, 1, 1),
612
503
        'snapshot_id': None,
613
504
        'volume_type_id': 'fakevoltype',
614
505
        'volume_metadata': [],
648
539
    raise exc.NotFound
649
540
 
650
541
 
651
 
def stub_volume_get_all(self, context, search_opts=None):
 
542
def stub_volume_get_all(context, search_opts=None):
 
543
    return [stub_volume(100, project_id='fake'),
 
544
            stub_volume(101, project_id='superfake'),
 
545
            stub_volume(102, project_id='superduperfake')]
 
546
 
 
547
 
 
548
def stub_volume_get_all_by_project(self, context, search_opts=None):
652
549
    return [stub_volume_get(self, context, '1')]
 
550
 
 
551
 
 
552
def stub_snapshot(id, **kwargs):
 
553
    snapshot = {
 
554
        'id': id,
 
555
        'volume_id': 12,
 
556
        'status': 'available',
 
557
        'volume_size': 100,
 
558
        'created_at': None,
 
559
        'display_name': 'Default name',
 
560
        'display_description': 'Default description',
 
561
        'project_id': 'fake'
 
562
        }
 
563
 
 
564
    snapshot.update(kwargs)
 
565
    return snapshot
 
566
 
 
567
 
 
568
def stub_snapshot_get_all(self):
 
569
    return [stub_snapshot(100, project_id='fake'),
 
570
            stub_snapshot(101, project_id='superfake'),
 
571
            stub_snapshot(102, project_id='superduperfake')]
 
572
 
 
573
 
 
574
def stub_snapshot_get_all_by_project(self, context):
 
575
    return [stub_snapshot(1)]