~0x44/nova/extdoc

« back to all changes in this revision

Viewing changes to nova/tests/image/test_glance.py

  • Committer: Tarmac
  • Author(s): Brian Waldon
  • Date: 2011-09-13 15:23:15 UTC
  • mfrom: (1517.2.17 image-service-cleanup)
  • Revision ID: tarmac-20110913152315-a21jg0bvjjlyga82
- remove translation of non-recognized attributes to user metadata, now just ignored
- ensure all keys are defined in image dictionaries, defaulting to None if glance client doesn't provide one
- remove BaseImageService
- reorganize some GlanceImageService tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
17
17
 
18
18
 
19
19
import datetime
20
 
import unittest
 
20
import stubout
21
21
 
 
22
from nova.tests.api.openstack import fakes
22
23
from nova import context
23
24
from nova import exception
 
25
from nova.image import glance
24
26
from nova import test
25
 
from nova.image import glance
26
 
 
27
 
 
28
 
class StubGlanceClient(object):
29
 
 
30
 
    def __init__(self, images, add_response=None, update_response=None):
31
 
        self.images = images
32
 
        self.add_response = add_response
33
 
        self.update_response = update_response
34
 
 
35
 
    def set_auth_token(self, auth_tok):
36
 
        pass
37
 
 
38
 
    def get_image_meta(self, image_id):
39
 
        return self.images[image_id]
40
 
 
41
 
    def get_images_detailed(self, filters=None, marker=None, limit=None):
42
 
        images = self.images.values()
43
 
        if marker is None:
44
 
            index = 0
45
 
        else:
46
 
            for index, image in enumerate(images):
47
 
                if image['id'] == marker:
48
 
                    index += 1
49
 
                    break
50
 
        # default to a page size of 3 to ensure we flex the pagination code
51
 
        return images[index:index + 3]
52
 
 
53
 
    def get_image(self, image_id):
54
 
        return self.images[image_id], []
55
 
 
56
 
    def add_image(self, metadata, data):
57
 
        return self.add_response
58
 
 
59
 
    def update_image(self, image_id, metadata, data):
60
 
        return self.update_response
 
27
from nova.tests.glance import stubs as glance_stubs
61
28
 
62
29
 
63
30
class NullWriter(object):
67
34
        pass
68
35
 
69
36
 
70
 
class BaseGlanceTest(unittest.TestCase):
71
 
    NOW_GLANCE_OLD_FORMAT = "2010-10-11T10:30:22"
72
 
    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22.000000"
73
 
    NOW_DATETIME = datetime.datetime(2010, 10, 11, 10, 30, 22)
74
 
 
75
 
    def setUp(self):
76
 
        self.client = StubGlanceClient(None)
77
 
        self.service = glance.GlanceImageService(client=self.client)
78
 
        self.context = context.RequestContext(None, None)
79
 
 
80
 
    def assertDateTimesFilled(self, image_meta):
81
 
        self.assertEqual(image_meta['created_at'], self.NOW_DATETIME)
82
 
        self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME)
83
 
        self.assertEqual(image_meta['deleted_at'], self.NOW_DATETIME)
84
 
 
85
 
    def assertDateTimesEmpty(self, image_meta):
86
 
        self.assertEqual(image_meta['updated_at'], None)
87
 
        self.assertEqual(image_meta['deleted_at'], None)
88
 
 
89
 
    def assertDateTimesBlank(self, image_meta):
90
 
        self.assertEqual(image_meta['updated_at'], '')
91
 
        self.assertEqual(image_meta['deleted_at'], '')
92
 
 
93
 
 
94
 
class TestGlanceImageServiceProperties(BaseGlanceTest):
95
 
    def test_show_passes_through_to_client(self):
96
 
        """Ensure attributes which aren't BASE_IMAGE_ATTRS are stored in the
97
 
        properties dict
98
 
        """
99
 
        fixtures = {'image1': {'id': '1', 'name': 'image1', 'is_public': True,
100
 
                               'foo': 'bar',
101
 
                               'properties': {'prop1': 'propvalue1'}}}
102
 
        self.client.images = fixtures
103
 
        image_meta = self.service.show(self.context, 'image1')
104
 
 
105
 
        expected = {'id': '1', 'name': 'image1', 'is_public': True,
106
 
                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}
107
 
        self.assertEqual(image_meta, expected)
108
 
 
109
 
    def test_show_raises_when_no_authtoken_in_the_context(self):
110
 
        fixtures = {'image1': {'name': 'image1', 'is_public': False,
111
 
                               'foo': 'bar',
112
 
                               'properties': {'prop1': 'propvalue1'}}}
113
 
        self.client.images = fixtures
114
 
        self.context.auth_token = False
115
 
 
116
 
        expected = {'name': 'image1', 'is_public': True,
117
 
                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}
118
 
        self.assertRaises(exception.ImageNotFound,
119
 
                          self.service.show, self.context, 'image1')
120
 
 
121
 
    def test_show_passes_through_to_client_with_authtoken_in_context(self):
122
 
        fixtures = {'image1': {'name': 'image1', 'is_public': False,
123
 
                               'foo': 'bar',
124
 
                               'properties': {'prop1': 'propvalue1'}}}
125
 
        self.client.images = fixtures
126
 
        self.context.auth_token = True
127
 
 
128
 
        expected = {'name': 'image1', 'is_public': False,
129
 
                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}
130
 
 
131
 
        image_meta = self.service.show(self.context, 'image1')
132
 
        self.assertEqual(image_meta, expected)
133
 
 
134
 
    def test_detail_passes_through_to_client(self):
135
 
        fixtures = {'image1': {'id': '1', 'name': 'image1', 'is_public': True,
136
 
                               'foo': 'bar',
137
 
                               'properties': {'prop1': 'propvalue1'}}}
138
 
        self.client.images = fixtures
139
 
        image_meta = self.service.detail(self.context)
140
 
        expected = [{'id': '1', 'name': 'image1', 'is_public': True,
141
 
                    'properties': {'prop1': 'propvalue1', 'foo': 'bar'}}]
142
 
        self.assertEqual(image_meta, expected)
143
 
 
144
 
 
145
 
class TestGetterDateTimeNoneTests(BaseGlanceTest):
146
 
 
147
 
    def test_show_handles_none_datetimes(self):
148
 
        self.client.images = self._make_none_datetime_fixtures()
149
 
        image_meta = self.service.show(self.context, 'image1')
150
 
        self.assertDateTimesEmpty(image_meta)
151
 
 
152
 
    def test_show_handles_blank_datetimes(self):
153
 
        self.client.images = self._make_blank_datetime_fixtures()
154
 
        image_meta = self.service.show(self.context, 'image1')
155
 
        self.assertDateTimesBlank(image_meta)
156
 
 
157
 
    def test_detail_handles_none_datetimes(self):
158
 
        self.client.images = self._make_none_datetime_fixtures()
159
 
        image_meta = self.service.detail(self.context)[0]
160
 
        self.assertDateTimesEmpty(image_meta)
161
 
 
162
 
    def test_detail_handles_blank_datetimes(self):
163
 
        self.client.images = self._make_blank_datetime_fixtures()
164
 
        image_meta = self.service.detail(self.context)[0]
165
 
        self.assertDateTimesBlank(image_meta)
166
 
 
167
 
    def test_get_handles_none_datetimes(self):
168
 
        self.client.images = self._make_none_datetime_fixtures()
169
 
        writer = NullWriter()
170
 
        image_meta = self.service.get(self.context, 'image1', writer)
171
 
        self.assertDateTimesEmpty(image_meta)
172
 
 
173
 
    def test_get_handles_blank_datetimes(self):
174
 
        self.client.images = self._make_blank_datetime_fixtures()
175
 
        writer = NullWriter()
176
 
        image_meta = self.service.get(self.context, 'image1', writer)
177
 
        self.assertDateTimesBlank(image_meta)
178
 
 
179
 
    def test_show_makes_datetimes(self):
180
 
        self.client.images = self._make_datetime_fixtures()
181
 
        image_meta = self.service.show(self.context, 'image1')
182
 
        self.assertDateTimesFilled(image_meta)
183
 
        image_meta = self.service.show(self.context, 'image2')
184
 
        self.assertDateTimesFilled(image_meta)
185
 
 
186
 
    def test_detail_makes_datetimes(self):
187
 
        self.client.images = self._make_datetime_fixtures()
188
 
        image_meta = self.service.detail(self.context)[0]
189
 
        self.assertDateTimesFilled(image_meta)
190
 
        image_meta = self.service.detail(self.context)[1]
191
 
        self.assertDateTimesFilled(image_meta)
192
 
 
193
 
    def test_get_makes_datetimes(self):
194
 
        self.client.images = self._make_datetime_fixtures()
195
 
        writer = NullWriter()
196
 
        image_meta = self.service.get(self.context, 'image1', writer)
197
 
        self.assertDateTimesFilled(image_meta)
198
 
        image_meta = self.service.get(self.context, 'image2', writer)
199
 
        self.assertDateTimesFilled(image_meta)
200
 
 
201
 
    def _make_datetime_fixtures(self):
202
 
        fixtures = {
203
 
            'image1': {
204
 
                'id': '1',
205
 
                'name': 'image1',
206
 
                'is_public': True,
207
 
                'created_at': self.NOW_GLANCE_FORMAT,
208
 
                'updated_at': self.NOW_GLANCE_FORMAT,
209
 
                'deleted_at': self.NOW_GLANCE_FORMAT,
210
 
            },
211
 
            'image2': {
212
 
                'id': '2',
213
 
                'name': 'image2',
214
 
                'is_public': True,
215
 
                'created_at': self.NOW_GLANCE_OLD_FORMAT,
216
 
                'updated_at': self.NOW_GLANCE_OLD_FORMAT,
217
 
                'deleted_at': self.NOW_GLANCE_OLD_FORMAT,
218
 
            },
219
 
        }
220
 
        return fixtures
221
 
 
222
 
    def _make_none_datetime_fixtures(self):
223
 
        fixtures = {'image1': {'id': '1',
224
 
                               'name': 'image1',
225
 
                               'is_public': True,
226
 
                               'updated_at': None,
227
 
                               'deleted_at': None}}
228
 
        return fixtures
229
 
 
230
 
    def _make_blank_datetime_fixtures(self):
231
 
        fixtures = {'image1': {'id': '1',
232
 
                               'name': 'image1',
233
 
                               'is_public': True,
234
 
                               'updated_at': '',
235
 
                               'deleted_at': ''}}
236
 
        return fixtures
237
 
 
238
 
 
239
 
class TestMutatorDateTimeTests(BaseGlanceTest):
240
 
    """Tests create(), update()"""
241
 
 
242
 
    def test_create_handles_datetimes(self):
243
 
        self.client.add_response = self._make_datetime_fixture()
244
 
        image_meta = self.service.create(self.context, {})
245
 
        self.assertDateTimesFilled(image_meta)
246
 
 
247
 
    def test_create_handles_none_datetimes(self):
248
 
        self.client.add_response = self._make_none_datetime_fixture()
249
 
        dummy_meta = {}
250
 
        image_meta = self.service.create(self.context, dummy_meta)
251
 
        self.assertDateTimesEmpty(image_meta)
252
 
 
253
 
    def test_update_handles_datetimes(self):
254
 
        self.client.images = {'image1': self._make_datetime_fixture()}
255
 
        self.client.update_response = self._make_datetime_fixture()
256
 
        dummy_meta = {}
257
 
        image_meta = self.service.update(self.context, 'image1', dummy_meta)
258
 
        self.assertDateTimesFilled(image_meta)
259
 
 
260
 
    def test_update_handles_none_datetimes(self):
261
 
        self.client.images = {'image1': self._make_datetime_fixture()}
262
 
        self.client.update_response = self._make_none_datetime_fixture()
263
 
        dummy_meta = {}
264
 
        image_meta = self.service.update(self.context, 'image1', dummy_meta)
265
 
        self.assertDateTimesEmpty(image_meta)
266
 
 
267
 
    def _make_datetime_fixture(self):
268
 
        fixture = {'id': 'image1', 'name': 'image1', 'is_public': True,
269
 
                   'created_at': self.NOW_GLANCE_FORMAT,
270
 
                   'updated_at': self.NOW_GLANCE_FORMAT,
271
 
                   'deleted_at': self.NOW_GLANCE_FORMAT}
272
 
        return fixture
273
 
 
274
 
    def _make_none_datetime_fixture(self):
275
 
        fixture = {'id': 'image1', 'name': 'image1', 'is_public': True,
276
 
                   'updated_at': None,
277
 
                   'deleted_at': None}
278
 
        return fixture
279
 
 
280
 
 
281
 
class TestGlanceSerializer(unittest.TestCase):
 
37
class TestGlanceSerializer(test.TestCase):
282
38
    def test_serialize(self):
283
39
        metadata = {'name': 'image1',
284
40
                    'is_public': True,
312
68
        converted = glance._convert_to_string(metadata)
313
69
        self.assertEqual(converted, converted_expected)
314
70
        self.assertEqual(glance._convert_from_string(converted), metadata)
 
71
 
 
72
 
 
73
class TestGlanceImageService(test.TestCase):
 
74
    """
 
75
    Tests the Glance image service.
 
76
 
 
77
    At a high level, the translations involved are:
 
78
 
 
79
        1. Glance -> ImageService - This is needed so we can support
 
80
           multple ImageServices (Glance, Local, etc)
 
81
 
 
82
        2. ImageService -> API - This is needed so we can support multple
 
83
           APIs (OpenStack, EC2)
 
84
 
 
85
    """
 
86
    NOW_GLANCE_OLD_FORMAT = "2010-10-11T10:30:22"
 
87
    NOW_GLANCE_FORMAT = "2010-10-11T10:30:22.000000"
 
88
    NOW_DATETIME = datetime.datetime(2010, 10, 11, 10, 30, 22)
 
89
 
 
90
    def setUp(self):
 
91
        super(TestGlanceImageService, self).setUp()
 
92
        self.stubs = stubout.StubOutForTesting()
 
93
        fakes.stub_out_compute_api_snapshot(self.stubs)
 
94
        client = glance_stubs.StubGlanceClient()
 
95
        self.service = glance.GlanceImageService(client=client)
 
96
        self.context = context.RequestContext('fake', 'fake', auth_token=True)
 
97
        self.service.delete_all()
 
98
 
 
99
    def tearDown(self):
 
100
        self.stubs.UnsetAll()
 
101
        super(TestGlanceImageService, self).tearDown()
 
102
 
 
103
    @staticmethod
 
104
    def _make_fixture(**kwargs):
 
105
        fixture = {'name': None,
 
106
                   'properties': {},
 
107
                   'status': None,
 
108
                   'is_public': None}
 
109
        fixture.update(kwargs)
 
110
        return fixture
 
111
 
 
112
    def _make_datetime_fixture(self):
 
113
        return self._make_fixture(created_at=self.NOW_GLANCE_FORMAT,
 
114
                                  updated_at=self.NOW_GLANCE_FORMAT,
 
115
                                  deleted_at=self.NOW_GLANCE_FORMAT)
 
116
 
 
117
    def test_create_with_instance_id(self):
 
118
        """Ensure instance_id is persisted as an image-property"""
 
119
        fixture = {'name': 'test image',
 
120
                   'is_public': False,
 
121
                   'properties': {'instance_id': '42', 'user_id': 'fake'}}
 
122
 
 
123
        image_id = self.service.create(self.context, fixture)['id']
 
124
        image_meta = self.service.show(self.context, image_id)
 
125
        expected = {
 
126
            'id': image_id,
 
127
            'name': 'test image',
 
128
            'is_public': False,
 
129
            'size': None,
 
130
            'location': None,
 
131
            'disk_format': None,
 
132
            'container_format': None,
 
133
            'checksum': None,
 
134
            'created_at': self.NOW_DATETIME,
 
135
            'updated_at': self.NOW_DATETIME,
 
136
            'deleted_at': None,
 
137
            'deleted': None,
 
138
            'status': None,
 
139
            'properties': {'instance_id': '42', 'user_id': 'fake'},
 
140
        }
 
141
        self.assertDictMatch(image_meta, expected)
 
142
 
 
143
        image_metas = self.service.detail(self.context)
 
144
        self.assertDictMatch(image_metas[0], expected)
 
145
 
 
146
    def test_create_without_instance_id(self):
 
147
        """
 
148
        Ensure we can create an image without having to specify an
 
149
        instance_id. Public images are an example of an image not tied to an
 
150
        instance.
 
151
        """
 
152
        fixture = {'name': 'test image', 'is_public': False}
 
153
        image_id = self.service.create(self.context, fixture)['id']
 
154
 
 
155
        expected = {
 
156
            'id': image_id,
 
157
            'name': 'test image',
 
158
            'is_public': False,
 
159
            'size': None,
 
160
            'location': None,
 
161
            'disk_format': None,
 
162
            'container_format': None,
 
163
            'checksum': None,
 
164
            'created_at': self.NOW_DATETIME,
 
165
            'updated_at': self.NOW_DATETIME,
 
166
            'deleted_at': None,
 
167
            'deleted': None,
 
168
            'status': None,
 
169
            'properties': {},
 
170
        }
 
171
        actual = self.service.show(self.context, image_id)
 
172
        self.assertDictMatch(actual, expected)
 
173
 
 
174
    def test_create(self):
 
175
        fixture = self._make_fixture(name='test image')
 
176
        num_images = len(self.service.index(self.context))
 
177
        image_id = self.service.create(self.context, fixture)['id']
 
178
 
 
179
        self.assertNotEquals(None, image_id)
 
180
        self.assertEquals(num_images + 1,
 
181
                          len(self.service.index(self.context)))
 
182
 
 
183
    def test_create_and_show_non_existing_image(self):
 
184
        fixture = self._make_fixture(name='test image')
 
185
        image_id = self.service.create(self.context, fixture)['id']
 
186
 
 
187
        self.assertNotEquals(None, image_id)
 
188
        self.assertRaises(exception.NotFound,
 
189
                          self.service.show,
 
190
                          self.context,
 
191
                          'bad image id')
 
192
 
 
193
    def test_create_and_show_non_existing_image_by_name(self):
 
194
        fixture = self._make_fixture(name='test image')
 
195
        image_id = self.service.create(self.context, fixture)['id']
 
196
 
 
197
        self.assertNotEquals(None, image_id)
 
198
        self.assertRaises(exception.ImageNotFound,
 
199
                          self.service.show_by_name,
 
200
                          self.context,
 
201
                          'bad image id')
 
202
 
 
203
    def test_index(self):
 
204
        fixture = self._make_fixture(name='test image')
 
205
        image_id = self.service.create(self.context, fixture)['id']
 
206
        image_metas = self.service.index(self.context)
 
207
        expected = [{'id': image_id, 'name': 'test image'}]
 
208
        self.assertDictListMatch(image_metas, expected)
 
209
 
 
210
    def test_index_default_limit(self):
 
211
        fixtures = []
 
212
        ids = []
 
213
        for i in range(10):
 
214
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
215
            fixtures.append(fixture)
 
216
            ids.append(self.service.create(self.context, fixture)['id'])
 
217
 
 
218
        image_metas = self.service.index(self.context)
 
219
        i = 0
 
220
        for meta in image_metas:
 
221
            expected = {'id': 'DONTCARE',
 
222
                        'name': 'TestImage %d' % (i)}
 
223
            self.assertDictMatch(meta, expected)
 
224
            i = i + 1
 
225
 
 
226
    def test_index_marker(self):
 
227
        fixtures = []
 
228
        ids = []
 
229
        for i in range(10):
 
230
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
231
            fixtures.append(fixture)
 
232
            ids.append(self.service.create(self.context, fixture)['id'])
 
233
 
 
234
        image_metas = self.service.index(self.context, marker=ids[1])
 
235
        self.assertEquals(len(image_metas), 8)
 
236
        i = 2
 
237
        for meta in image_metas:
 
238
            expected = {'id': 'DONTCARE',
 
239
                        'name': 'TestImage %d' % (i)}
 
240
            self.assertDictMatch(meta, expected)
 
241
            i = i + 1
 
242
 
 
243
    def test_index_limit(self):
 
244
        fixtures = []
 
245
        ids = []
 
246
        for i in range(10):
 
247
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
248
            fixtures.append(fixture)
 
249
            ids.append(self.service.create(self.context, fixture)['id'])
 
250
 
 
251
        image_metas = self.service.index(self.context, limit=5)
 
252
        self.assertEquals(len(image_metas), 5)
 
253
 
 
254
    def test_index_marker_and_limit(self):
 
255
        fixtures = []
 
256
        ids = []
 
257
        for i in range(10):
 
258
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
259
            fixtures.append(fixture)
 
260
            ids.append(self.service.create(self.context, fixture)['id'])
 
261
 
 
262
        image_metas = self.service.index(self.context, marker=ids[3], limit=1)
 
263
        self.assertEquals(len(image_metas), 1)
 
264
        i = 4
 
265
        for meta in image_metas:
 
266
            expected = {'id': ids[i],
 
267
                        'name': 'TestImage %d' % (i)}
 
268
            self.assertDictMatch(meta, expected)
 
269
            i = i + 1
 
270
 
 
271
    def test_detail_marker(self):
 
272
        fixtures = []
 
273
        ids = []
 
274
        for i in range(10):
 
275
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
276
            fixtures.append(fixture)
 
277
            ids.append(self.service.create(self.context, fixture)['id'])
 
278
 
 
279
        image_metas = self.service.detail(self.context, marker=ids[1])
 
280
        self.assertEquals(len(image_metas), 8)
 
281
        i = 2
 
282
        for meta in image_metas:
 
283
            expected = {
 
284
                'id': ids[i],
 
285
                'status': None,
 
286
                'is_public': None,
 
287
                'name': 'TestImage %d' % (i),
 
288
                'properties': {},
 
289
                'size': None,
 
290
                'location': None,
 
291
                'disk_format': None,
 
292
                'container_format': None,
 
293
                'checksum': None,
 
294
                'created_at': self.NOW_DATETIME,
 
295
                'updated_at': self.NOW_DATETIME,
 
296
                'deleted_at': None,
 
297
                'deleted': None
 
298
            }
 
299
 
 
300
            self.assertDictMatch(meta, expected)
 
301
            i = i + 1
 
302
 
 
303
    def test_detail_limit(self):
 
304
        fixtures = []
 
305
        ids = []
 
306
        for i in range(10):
 
307
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
308
            fixtures.append(fixture)
 
309
            ids.append(self.service.create(self.context, fixture)['id'])
 
310
 
 
311
        image_metas = self.service.detail(self.context, limit=5)
 
312
        self.assertEquals(len(image_metas), 5)
 
313
 
 
314
    def test_detail_marker_and_limit(self):
 
315
        fixtures = []
 
316
        ids = []
 
317
        for i in range(10):
 
318
            fixture = self._make_fixture(name='TestImage %d' % (i))
 
319
            fixtures.append(fixture)
 
320
            ids.append(self.service.create(self.context, fixture)['id'])
 
321
 
 
322
        image_metas = self.service.detail(self.context, marker=ids[3], limit=5)
 
323
        self.assertEquals(len(image_metas), 5)
 
324
        i = 4
 
325
        for meta in image_metas:
 
326
            expected = {
 
327
                'id': ids[i],
 
328
                'status': None,
 
329
                'is_public': None,
 
330
                'name': 'TestImage %d' % (i),
 
331
                'properties': {},
 
332
                'size': None,
 
333
                'location': None,
 
334
                'disk_format': None,
 
335
                'container_format': None,
 
336
                'checksum': None,
 
337
                'created_at': self.NOW_DATETIME,
 
338
                'updated_at': self.NOW_DATETIME,
 
339
                'deleted_at': None,
 
340
                'deleted': None
 
341
            }
 
342
            self.assertDictMatch(meta, expected)
 
343
            i = i + 1
 
344
 
 
345
    def test_update(self):
 
346
        fixture = self._make_fixture(name='test image')
 
347
        image_id = self.service.create(self.context, fixture)['id']
 
348
        fixture['name'] = 'new image name'
 
349
        self.service.update(self.context, image_id, fixture)
 
350
 
 
351
        new_image_data = self.service.show(self.context, image_id)
 
352
        self.assertEquals('new image name', new_image_data['name'])
 
353
 
 
354
    def test_delete(self):
 
355
        fixture1 = self._make_fixture(name='test image 1')
 
356
        fixture2 = self._make_fixture(name='test image 2')
 
357
        fixtures = [fixture1, fixture2]
 
358
 
 
359
        num_images = len(self.service.index(self.context))
 
360
        self.assertEquals(0, num_images, str(self.service.index(self.context)))
 
361
 
 
362
        ids = []
 
363
        for fixture in fixtures:
 
364
            new_id = self.service.create(self.context, fixture)['id']
 
365
            ids.append(new_id)
 
366
 
 
367
        num_images = len(self.service.index(self.context))
 
368
        self.assertEquals(2, num_images, str(self.service.index(self.context)))
 
369
 
 
370
        self.service.delete(self.context, ids[0])
 
371
 
 
372
        num_images = len(self.service.index(self.context))
 
373
        self.assertEquals(1, num_images)
 
374
 
 
375
    def test_show_passes_through_to_client(self):
 
376
        fixture = self._make_fixture(name='image1', is_public=True)
 
377
        image_id = self.service.create(self.context, fixture)['id']
 
378
 
 
379
        image_meta = self.service.show(self.context, image_id)
 
380
        expected = {
 
381
            'id': image_id,
 
382
            'name': 'image1',
 
383
            'is_public': True,
 
384
            'size': None,
 
385
            'location': None,
 
386
            'disk_format': None,
 
387
            'container_format': None,
 
388
            'checksum': None,
 
389
            'created_at': self.NOW_DATETIME,
 
390
            'updated_at': self.NOW_DATETIME,
 
391
            'deleted_at': None,
 
392
            'deleted': None,
 
393
            'status': None,
 
394
            'properties': {},
 
395
        }
 
396
        self.assertEqual(image_meta, expected)
 
397
 
 
398
    def test_show_raises_when_no_authtoken_in_the_context(self):
 
399
        fixture = self._make_fixture(name='image1',
 
400
                                     is_public=False,
 
401
                                     properties={'one': 'two'})
 
402
        image_id = self.service.create(self.context, fixture)['id']
 
403
        self.context.auth_token = False
 
404
        self.assertRaises(exception.ImageNotFound,
 
405
                          self.service.show,
 
406
                          self.context,
 
407
                          image_id)
 
408
 
 
409
    def test_detail_passes_through_to_client(self):
 
410
        fixture = self._make_fixture(name='image10', is_public=True)
 
411
        image_id = self.service.create(self.context, fixture)['id']
 
412
        image_metas = self.service.detail(self.context)
 
413
        expected = [
 
414
            {
 
415
                'id': image_id,
 
416
                'name': 'image10',
 
417
                'is_public': True,
 
418
                'size': None,
 
419
                'location': None,
 
420
                'disk_format': None,
 
421
                'container_format': None,
 
422
                'checksum': None,
 
423
                'created_at': self.NOW_DATETIME,
 
424
                'updated_at': self.NOW_DATETIME,
 
425
                'deleted_at': None,
 
426
                'deleted': None,
 
427
                'status': None,
 
428
                'properties': {},
 
429
            },
 
430
        ]
 
431
        self.assertEqual(image_metas, expected)
 
432
 
 
433
    def test_show_makes_datetimes(self):
 
434
        fixture = self._make_datetime_fixture()
 
435
        image_id = self.service.create(self.context, fixture)['id']
 
436
        image_meta = self.service.show(self.context, image_id)
 
437
        self.assertEqual(image_meta['created_at'], self.NOW_DATETIME)
 
438
        self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME)
 
439
 
 
440
    def test_detail_makes_datetimes(self):
 
441
        fixture = self._make_datetime_fixture()
 
442
        self.service.create(self.context, fixture)
 
443
        image_meta = self.service.detail(self.context)[0]
 
444
        self.assertEqual(image_meta['created_at'], self.NOW_DATETIME)
 
445
        self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME)
 
446
 
 
447
    def test_get_makes_datetimes(self):
 
448
        fixture = self._make_datetime_fixture()
 
449
        image_id = self.service.create(self.context, fixture)['id']
 
450
        writer = NullWriter()
 
451
        image_meta = self.service.get(self.context, image_id, writer)
 
452
        self.assertEqual(image_meta['created_at'], self.NOW_DATETIME)
 
453
        self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME)