← Back to branch summary

~ubuntu-cloud-archive/ubuntu/precise/glance/folsom

« back to all changes in this revision

Viewing changes to glance/tests/functional/db/__init__.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Chuck Short, Soren Hansen
  • Date: 2012-09-07 12:17:46 UTC
  • mfrom: (1.1.42)
  • Revision ID: package-import@ubuntu.com-20120907121746-a4i0aewhlzb7vw31
Tags: 2012.2~rc1~20120907.129.f0bd856-0ubuntu1
https://launchpad.net/bugs/820688
[ Chuck Short ]
* New upstream version.
* drop debian/patches/fix-docs-build.patch. 
* debian/rules: Re-activate tests.
* debain/control: Add depends on python-swiftclient.
* debian/*.usptart: make glance start from runlevel 1 to runlevel
  2. (LP: #820688)

[ Soren Hansen ]
* Update debian/watch to account for symbolically named tarballs and
  use newer URL.
* New snapshot.
* Refresh disable-network-for-docs.patch
* Fix Launchpad URLs in debian/watch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
glance/tests/functional/db/__init__.py
18
18
 
19
19
import copy
20
20
import datetime
 
21
import uuid
21
22
 
22
23
from glance.common import exception
23
24
from glance.common import utils
97
98
    def reset(self):
98
99
        pass
99
100
 
 
101
    def test_image_create_requires_status(self):
 
102
        fixture = {'name': 'mark', 'size': 12}
 
103
        self.assertRaises(exception.Invalid,
 
104
                          self.db_api.image_create, self.context, fixture)
 
105
        fixture = {'name': 'mark', 'size': 12, 'status': 'queued'}
 
106
        self.db_api.image_create(self.context, fixture)
 
107
 
100
108
    def test_image_create_defaults(self):
101
109
        image = self.db_api.image_create(self.context, {'status': 'queued'})
102
 
        self.assertTrue(image['id'])
 
110
 
 
111
        self.assertEqual(None, image['name'])
 
112
        self.assertEqual(None, image['container_format'])
 
113
        self.assertEqual(0, image['min_ram'])
 
114
        self.assertEqual(0, image['min_disk'])
 
115
        self.assertEqual(None, image['owner'])
 
116
        self.assertEqual(False, image['is_public'])
 
117
        self.assertEqual(None, image['size'])
 
118
        self.assertEqual(None, image['checksum'])
 
119
        self.assertEqual(None, image['disk_format'])
 
120
        self.assertEqual(None, image['location'])
 
121
        self.assertEqual(False, image['protected'])
 
122
        self.assertEqual(False, image['deleted'])
 
123
        self.assertEqual(None, image['deleted_at'])
103
124
        self.assertEqual([], image['properties'])
104
125
 
 
126
        # These values aren't predictable, but they should be populated
 
127
        self.assertTrue(uuid.UUID(image['id']))
 
128
        self.assertTrue(isinstance(image['created_at'], datetime.datetime))
 
129
        self.assertTrue(isinstance(image['updated_at'], datetime.datetime))
 
130
 
 
131
        #NOTE(bcwaldon): the tags attribute should not be returned as a part
 
132
        # of a core image entity
 
133
        self.assertFalse('tags' in image)
 
134
 
 
135
    def test_image_create_duplicate_id(self):
 
136
        self.assertRaises(exception.Duplicate,
 
137
                          self.db_api.image_create,
 
138
                          self.context, {'id': UUID1, 'status': 'queued'})
 
139
 
105
140
    def test_image_create_properties(self):
106
141
        fixture = {'status': 'queued', 'properties': {'ping': 'pong'}}
107
142
        image = self.db_api.image_create(self.context, fixture)
110
145
                  for p in image['properties']]
111
146
        self.assertEqual(expected, actual)
112
147
 
 
148
    def test_image_create_unknown_attribtues(self):
 
149
        fixture = {'ping': 'pong'}
 
150
        self.assertRaises(exception.Invalid,
 
151
                          self.db_api.image_create, self.context, fixture)
 
152
 
 
153
    def test_image_update_core_attribute(self):
 
154
        fixture = {'status': 'queued'}
 
155
        image = self.db_api.image_update(self.adm_context, UUID3, fixture)
 
156
        self.assertEqual('queued', image['status'])
 
157
        self.assertNotEqual(image['created_at'], image['updated_at'])
 
158
 
 
159
    def test_image_update(self):
 
160
        fixture = {'status': 'queued', 'properties': {'ping': 'pong'}}
 
161
        image = self.db_api.image_update(self.adm_context, UUID3, fixture)
 
162
        expected = [{'name': 'ping', 'value': 'pong'}]
 
163
        actual = [{'name': p['name'], 'value': p['value']}
 
164
                  for p in image['properties']]
 
165
        self.assertEqual(expected, actual)
 
166
        self.assertEqual('queued', image['status'])
 
167
        self.assertNotEqual(image['created_at'], image['updated_at'])
 
168
 
 
169
    def test_image_update_properties(self):
 
170
        fixture = {'properties': {'ping': 'pong'}}
 
171
        image = self.db_api.image_update(self.adm_context, UUID1, fixture)
 
172
        expected = {'ping': 'pong', 'foo': 'bar'}
 
173
        actual = dict((p['name'], p['value']) for p in image['properties'])
 
174
        self.assertEqual(expected, actual)
 
175
        self.assertNotEqual(image['created_at'], image['updated_at'])
 
176
 
 
177
    def test_image_update_purge_properties(self):
 
178
        fixture = {'properties': {'ping': 'pong'}}
 
179
        image = self.db_api.image_update(self.adm_context, UUID1,
 
180
                                         fixture, purge_props=True)
 
181
        properties = dict((p['name'], p) for p in image['properties'])
 
182
 
 
183
        # New properties are set
 
184
        self.assertTrue('ping' in properties)
 
185
        self.assertEqual(properties['ping']['value'], 'pong')
 
186
        self.assertEqual(properties['ping']['deleted'], False)
 
187
 
 
188
        # Original properties still show up, but with deleted=True
 
189
        # TODO(markwash): db api should not return deleted properties
 
190
        self.assertTrue('foo' in properties)
 
191
        self.assertEqual(properties['foo']['value'], 'bar')
 
192
        self.assertEqual(properties['foo']['deleted'], True)
 
193
 
113
194
    def test_image_property_delete(self):
114
195
        fixture = {'name': 'ping', 'value': 'pong', 'image_id': UUID1}
115
196
        prop = self.db_api.image_property_create(self.context, fixture)
138
219
                                      force_show_deleted=True)
139
220
        self.assertEquals(image['id'], self.fixtures[0]['id'])
140
221
 
 
222
    def test_image_get_not_owned(self):
 
223
        TENANT1 = utils.generate_uuid()
 
224
        TENANT2 = utils.generate_uuid()
 
225
        ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
 
226
        ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
 
227
        image = self.db_api.image_create(
 
228
                ctxt1, {'status': 'queued', 'owner': TENANT1})
 
229
        self.assertRaises(exception.Forbidden,
 
230
                          self.db_api.image_get, ctxt2, image['id'])
 
231
 
 
232
    def test_image_get_not_found(self):
 
233
        UUID = utils.generate_uuid()
 
234
        self.assertRaises(exception.NotFound,
 
235
                          self.db_api.image_get, self.context, UUID)
 
236
 
141
237
    def test_image_get_all(self):
142
238
        images = self.db_api.image_get_all(self.context)
143
239
        self.assertEquals(3, len(images))
251
347
        images = self.db_api.image_get_all(self.context, limit=0)
252
348
        self.assertEquals(0, len(images))
253
349
 
 
350
    def test_image_get_all_owned(self):
 
351
        TENANT1 = utils.generate_uuid()
 
352
        ctxt1 = context.RequestContext(is_admin=False, tenant=TENANT1)
 
353
        UUIDX = utils.generate_uuid()
 
354
        self.db_api.image_create(ctxt1,
 
355
                {'id': UUIDX, 'status': 'queued', 'owner': TENANT1})
 
356
 
 
357
        TENANT2 = utils.generate_uuid()
 
358
        ctxt2 = context.RequestContext(is_admin=False, tenant=TENANT2)
 
359
        UUIDY = utils.generate_uuid()
 
360
        self.db_api.image_create(ctxt2,
 
361
                {'id': UUIDY, 'status': 'queued', 'owner': TENANT2})
 
362
 
 
363
        # NOTE(bcwaldon): the is_public=True flag indicates that you want
 
364
        # to get all images that are public AND those that are owned by the
 
365
        # calling context
 
366
        images = self.db_api.image_get_all(ctxt1, filters={'is_public': True})
 
367
        image_ids = [image['id'] for image in images]
 
368
        expected = [UUIDX, UUID3, UUID2, UUID1]
 
369
        self.assertEqual(sorted(expected), sorted(image_ids))
 
370
 
254
371
    def test_image_paginate(self):
255
372
        """Paginate through a list of images using limit and marker"""
256
373
        extra_uuids = [utils.generate_uuid() for i in range(2)]