Revision 2d04422f

b/snf-cyclades-app/synnefo/api/test/flavors.py
50 50
        response = self.get('/api/v1.1/flavors')
51 51
        self.assertSuccess(response)
52 52

  
53
        api_flavors = json.loads(response.content)['flavors']['values']
53
        api_flavors = json.loads(response.content)['flavors']
54 54
        db_flavors = Flavor.objects.filter(deleted=False)
55 55
        self.assertEqual(len(api_flavors), len(db_flavors))
56 56
        for api_flavor in api_flavors:
......
64 64
        self.assertSuccess(response)
65 65

  
66 66
        db_flavors = Flavor.objects.filter(deleted=False)
67
        api_flavors = json.loads(response.content)['flavors']['values']
67
        api_flavors = json.loads(response.content)['flavors']
68 68

  
69 69
        self.assertEqual(len(db_flavors), len(api_flavors))
70 70

  
......
108 108
        """Test that deleted flavors do not appear to flavors list"""
109 109
        response = self.get('/api/v1.1/flavors')
110 110
        self.assertSuccess(response)
111
        api_flavors = json.loads(response.content)['flavors']['values']
111
        api_flavors = json.loads(response.content)['flavors']
112 112
        self.assertEqual(len(api_flavors), 2)
113 113

  
114 114
    def test_deleted_flavors_details(self):
......
116 116
        FlavorFactory(deleted=True)
117 117
        response = self.get('/api/v1.1/flavors/detail')
118 118
        self.assertSuccess(response)
119
        api_flavors = json.loads(response.content)['flavors']['values']
119
        api_flavors = json.loads(response.content)['flavors']
120 120
        self.assertEqual(len(api_flavors), 2)
121 121

  
122 122
    def test_wrong_flavor(self):
b/snf-cyclades-app/synnefo/api/test/images.py
69 69
        mimage().list_images.return_value = images
70 70
        response = self.get('/api/v1.1/images/', 'user')
71 71
        self.assertSuccess(response)
72
        api_images = json.loads(response.content)['images']['values']
72
        api_images = json.loads(response.content)['images']
73 73
        self.assertEqual(images, api_images)
74 74

  
75 75
    @assert_backend_closed
......
102 102
                   'progress': 100,
103 103
                   'created': '2012-11-26T11:52:54+00:00',
104 104
                   'updated': '2012-12-26T11:52:54+00:00',
105
                   'metadata': {'values': {'foo':'bar'}}},
105
                   'metadata': {'foo':'bar'}},
106 106
                  {'id': 2,
107 107
                   'name': 'image-2',
108 108
                   'status': 'DELETED',
......
118 118
        mimage().list_images.return_value = images
119 119
        response = self.get('/api/v1.1/images/detail', 'user')
120 120
        self.assertSuccess(response)
121
        api_images = json.loads(response.content)['images']['values']
121
        api_images = json.loads(response.content)['images']
122 122
        self.assertEqual(len(result_images), len(api_images))
123 123
        self.assertEqual(result_images, api_images)
124 124

  
......
150 150
        response =\
151 151
            self.get('/api/v1.1/images/detail?changes-since=%sUTC' % new_time)
152 152
        self.assertSuccess(response)
153
        api_images = json.loads(response.content)['images']['values']
153
        api_images = json.loads(response.content)['images']
154 154
        self.assertEqual(1, len(api_images))
155 155

  
156 156
    @assert_backend_closed
......
169 169
                   'progress': 100,
170 170
                   'created': '2012-11-26T11:52:54+00:00',
171 171
                   'updated': '2012-12-26T11:52:54+00:00',
172
                   'metadata': {'values': {'foo': 'bar'}}}
172
                   'metadata': {'foo': 'bar'}}
173 173
        mimage.return_value.get_image.return_value = image
174 174
        response = self.get('/api/v1.1/images/42', 'user')
175 175
        self.assertSuccess(response)
......
207 207
                   'progress': 100,
208 208
                   'created': '2012-11-26T11:52:54+00:00',
209 209
                   'updated': '2012-12-26T11:52:54+00:00',
210
                   'metadata': {'values': {'foo': 'bar'}}}
210
                   'metadata': {'foo': 'bar'}}
211 211

  
212 212
    @assert_backend_closed
213 213
    def test_list_metadata(self, backend):
214 214
        backend.return_value.get_image.return_value = self.image
215
        response = self.get('/api/v1.1/images/42/meta', 'user')
215
        response = self.get('/api/v1.1/images/42/metadata', 'user')
216 216
        self.assertSuccess(response)
217
        meta = json.loads(response.content)['metadata']['values']
217
        meta = json.loads(response.content)['metadata']
218 218
        self.assertEqual(meta, self.image['properties'])
219 219

  
220 220
    @assert_backend_closed
221 221
    def test_get_metadata(self, backend):
222 222
        backend.return_value.get_image.return_value = self.image
223
        response = self.get('/api/v1.1/images/42/meta/foo', 'user')
223
        response = self.get('/api/v1.1/images/42/metadata/foo', 'user')
224 224
        self.assertSuccess(response)
225 225
        meta = json.loads(response.content)['meta']
226 226
        self.assertEqual(meta['foo'], 'bar')
......
228 228
    @assert_backend_closed
229 229
    def test_get_invalid_metadata(self, backend):
230 230
        backend.return_value.get_image.return_value = self.image
231
        response = self.get('/api/v1.1/images/42/meta/not_found', 'user')
231
        response = self.get('/api/v1.1/images/42/metadata/not_found', 'user')
232 232
        self.assertItemNotFound(response)
233 233

  
234 234
    def test_delete_metadata_item(self, backend):
235 235
        backend.return_value.get_image.return_value = self.image
236
        response = self.delete('/api/v1.1/images/42/meta/foo', 'user')
236
        response = self.delete('/api/v1.1/images/42/metadata/foo', 'user')
237 237
        self.assertEqual(response.status_code, 204)
238 238
        backend.return_value.update_metadata.assert_called_once_with('42', {'properties': {'foo2':
239 239
                                                    'bar2'}})
......
242 242
    def test_create_metadata_item(self, backend):
243 243
        backend.return_value.get_image.return_value = self.image
244 244
        request = {'meta': {'foo3': 'bar3'}}
245
        response = self.put('/api/v1.1/images/42/meta/foo3', 'user',
245
        response = self.put('/api/v1.1/images/42/metadata/foo3', 'user',
246 246
                            json.dumps(request), 'json')
247 247
        self.assertEqual(response.status_code, 201)
248 248
        backend.return_value.update_metadata.assert_called_once_with('42',
......
253 253
    def test_create_metadata_malformed_1(self, backend):
254 254
        backend.return_value.get_image.return_value = self.image
255 255
        request = {'met': {'foo3': 'bar3'}}
256
        response = self.put('/api/v1.1/images/42/meta/foo3', 'user',
256
        response = self.put('/api/v1.1/images/42/metadata/foo3', 'user',
257 257
                            json.dumps(request), 'json')
258 258
        self.assertBadRequest(response)
259 259

  
260 260
    @assert_backend_closed
261 261
    def test_create_metadata_malformed_2(self, backend):
262 262
        backend.return_value.get_image.return_value = self.image
263
        request = {'meta': [('foo3', 'bar3')]}
264
        response = self.put('/api/v1.1/images/42/meta/foo3', 'user',
263
        request = {'metadata': [('foo3', 'bar3')]}
264
        response = self.put('/api/v1.1/images/42/metadata/foo3', 'user',
265 265
                            json.dumps(request), 'json')
266 266
        self.assertBadRequest(response)
267 267

  
......
269 269
    def test_create_metadata_malformed_3(self, backend):
270 270
        backend.return_value.get_image.return_value = self.image
271 271
        request = {'met': {'foo3': 'bar3', 'foo4': 'bar4'}}
272
        response = self.put('/api/v1.1/images/42/meta/foo3', 'user',
272
        response = self.put('/api/v1.1/images/42/metadata/foo3', 'user',
273 273
                                json.dumps(request), 'json')
274 274
        self.assertBadRequest(response)
275 275

  
......
277 277
    def test_create_metadata_malformed_4(self, backend):
278 278
        backend.return_value.get_image.return_value = self.image
279 279
        request = {'met': {'foo3': 'bar3'}}
280
        response = self.put('/api/v1.1/images/42/meta/foo4', 'user',
280
        response = self.put('/api/v1.1/images/42/metadata/foo4', 'user',
281 281
                                json.dumps(request), 'json')
282 282
        self.assertBadRequest(response)
283 283

  
......
285 285
    def test_update_metadata_item(self, backend):
286 286
        backend.return_value.get_image.return_value = self.image
287 287
        request = {'metadata': {'foo': 'bar_new', 'foo4': 'bar4'}}
288
        response = self.post('/api/v1.1/images/42/meta', 'user',
288
        response = self.post('/api/v1.1/images/42/metadata', 'user',
289 289
                             json.dumps(request), 'json')
290 290
        self.assertEqual(response.status_code, 201)
291 291
        backend.return_value.update_metadata.assert_called_once_with('42',
......
297 297
    def test_update_metadata_malformed(self, backend):
298 298
        backend.return_value.get_image.return_value = self.image
299 299
        request = {'meta': {'foo': 'bar_new', 'foo4': 'bar4'}}
300
        response = self.post('/api/v1.1/images/42/meta', 'user',
300
        response = self.post('/api/v1.1/images/42/metadata', 'user',
301 301
                            json.dumps(request), 'json')
302 302
        self.assertBadRequest(response)
b/snf-cyclades-app/synnefo/api/test/networks.py
68 68
            self.assertEqual(db_net.public, api_net['public'])
69 69
            db_nics = ["nic-%d-%d" % (nic.machine.id, nic.index) for nic in
70 70
                       db_net.nics.filter(machine__userid=db_net.userid)]
71
            self.assertEqual(db_nics, api_net['attachments']['values'])
71
            self.assertEqual(db_nics, api_net['attachments'])
72 72

  
73 73
    def test_create_network_1(self, mrapi):
74 74
        request = {
......
189 189
        self.assertSuccess(response)
190 190

  
191 191
        db_nets = Network.objects.filter(userid=self.user, deleted=False)
192
        api_nets = json.loads(response.content)["networks"]["values"]
192
        api_nets = json.loads(response.content)["networks"]
193 193

  
194 194
        self.assertEqual(len(db_nets), len(api_nets))
195 195
        for api_net in api_nets:
......
205 205
        self.assertSuccess(response)
206 206

  
207 207
        db_nets = Network.objects.filter(userid=self.user, deleted=False)
208
        api_nets = json.loads(response.content)["networks"]["values"]
208
        api_nets = json.loads(response.content)["networks"]
209 209

  
210 210
        self.assertEqual(len(db_nets), len(api_nets))
211 211
        for api_net in api_nets:
......
222 222
                            net.userid)
223 223
        self.assertSuccess(response)
224 224
        api_net = json.loads(response.content)["network"]
225
        self.assertEqual(len(api_net["attachments"]["values"]), 0)
225
        self.assertEqual(len(api_net["attachments"]), 0)
226 226

  
227 227
    def test_network_details_1(self, mrapi):
228 228
        """Test that expected details for a network are returned"""
b/snf-cyclades-app/synnefo/api/test/servers.py
55 55
        """Test if the expected list of servers is returned."""
56 56
        response = self.get('/api/v1.1/servers')
57 57
        self.assertSuccess(response)
58
        servers = json.loads(response.content)['servers']['values']
58
        servers = json.loads(response.content)['servers']
59 59
        self.assertEqual(servers, [])
60 60

  
61 61
    def test_server_list_2(self):
62 62
        """Test if the expected list of servers is returned."""
63 63
        response = self.get('/api/v1.1/servers', self.user1)
64 64
        self.assertSuccess(response)
65
        servers = json.loads(response.content)['servers']['values']
65
        servers = json.loads(response.content)['servers']
66 66
        db_server = self.vm1
67 67
        self.assertEqual(servers, [{'name': db_server.name,
68 68
                                    'id': db_server.id}])
......
74 74
                    self.vm4.id: self.vm4}
75 75

  
76 76
        response = self.get('/api/v1.1/servers/detail', user)
77
        servers = json.loads(response.content)['servers']['values']
77
        servers = json.loads(response.content)['servers']
78 78
        self.assertEqual(len(servers), len(user_vms))
79 79
        for api_vm in servers:
80 80
            db_vm = user_vms[api_vm['id']]
......
104 104
        self.assertEqual(server['image'], db_vm.imageid)
105 105
        self.assertEqual(server['name'], db_vm.name)
106 106
        self.assertEqual(server['status'], get_rsapi_state(db_vm))
107
        api_nic = server['attachments']['values'][0]
107
        api_nic = server['attachments'][0]
108 108
        self.assertEqual(api_nic['network_id'], str(net.id))
109 109
        self.assertEqual(api_nic['mac_address'], nic.mac)
110 110
        self.assertEqual(api_nic['firewallProfile'], nic.firewall_profile)
......
112 112
        self.assertEqual(api_nic['ipv6'], nic.ipv6)
113 113
        self.assertEqual(api_nic['id'], 'nic-%s-%s' % (db_vm.id, nic.index))
114 114

  
115
        metadata = server['metadata']['values']
115
        metadata = server['metadata']
116 116
        self.assertEqual(len(metadata), 1)
117 117
        self.assertEqual(metadata[db_vm_meta.meta_key], db_vm_meta.meta_value)
118 118
        self.assertSuccess(response)
......
132 132

  
133 133
        response = self.get('/api/v1.1/servers/%d' % db_vm.id, user)
134 134
        server = json.loads(response.content)['server']
135
        nics = server["attachments"]["values"]
135
        nics = server["attachments"]
136 136
        self.assertEqual(len(nics), 1)
137 137
        self.assertEqual(nics[0]["network_id"], str(nic2.network_id))
138 138

  
......
203 203
        api_server = json.loads(response.content)['server']
204 204
        self.assertEqual(api_server['status'], "BUILD")
205 205
        self.assertEqual(api_server['progress'], 0)
206
        self.assertEqual(api_server['metadata']['values'],
206
        self.assertEqual(api_server['metadata'],
207 207
                        {"My Server Name":  "Apache1"})
208 208
        self.assertTrue('adminPass' in api_server)
209 209

  
......
253 253
        vm = self.vm
254 254
        create_meta = lambda: mfactory.VirtualMachineMetadataFactory(vm=vm)
255 255
        metadata = [create_meta(), create_meta(), create_meta()]
256
        response = self.get('/api/v1.1/servers/%d/meta' % vm.id, vm.userid)
256
        response = self.get('/api/v1.1/servers/%d/metadata' % vm.id, vm.userid)
257 257
        self.assertTrue(response.status_code in [200, 203])
258
        api_metadata = json.loads(response.content)['metadata']['values']
258
        api_metadata = json.loads(response.content)['metadata']
259 259
        self.assertEqual(len(api_metadata), len(metadata) + 1)
260 260
        for db_m in metadata:
261 261
            self.assertEqual(api_metadata[db_m.meta_key], db_m.meta_value)
......
264 264
                        {'foo': 'bar'},
265 265
                        metadata[0].meta_key: 'bar2'
266 266
                  }
267
        response = self.post('/api/v1.1/servers/%d/meta' % vm.id, vm.userid,
268
                             json.dumps(request), 'json')
267
        response = self.post('/api/v1.1/servers/%d/metadata' % vm.id,
268
                             vm.userid, json.dumps(request), 'json')
269 269
        metadata2 = VirtualMachineMetadata.objects.filter(vm=vm)
270
        response = self.get('/api/v1.1/servers/%d/meta' % vm.id, vm.userid)
270
        response = self.get('/api/v1.1/servers/%d/metadata' % vm.id, vm.userid)
271 271
        self.assertTrue(response.status_code in [200, 203])
272
        api_metadata2 = json.loads(response.content)['metadata']['values']
272
        api_metadata2 = json.loads(response.content)['metadata']
273 273
        self.assertTrue('foo' in api_metadata2.keys())
274 274
        self.assertTrue(api_metadata2[metadata[0].meta_key], 'bar2')
275 275
        self.assertEqual(len(api_metadata2), len(metadata2))
......
278 278

  
279 279
        # Create new meta
280 280
        request = {'meta': {'foo2': 'bar2'}}
281
        response = self.put('/api/v1.1/servers/%d/meta/foo2' % vm.id,
281
        response = self.put('/api/v1.1/servers/%d/metadata/foo2' % vm.id,
282 282
                            vm.userid, json.dumps(request), 'json')
283 283

  
284 284
        # Get the new meta
285
        response = self.get('/api/v1.1/servers/%d/meta/foo2' % vm.id,
285
        response = self.get('/api/v1.1/servers/%d/metadata/foo2' % vm.id,
286 286
                            vm.userid)
287 287
        meta = json.loads(response.content)['meta']
288 288
        self.assertEqual(meta['foo2'], 'bar2')
289 289

  
290 290
        # Delete the new meta
291
        response = self.delete('/api/v1.1/servers/%d/meta/foo2' % vm.id,
291
        response = self.delete('/api/v1.1/servers/%d/metadata/foo2' % vm.id,
292 292
                               vm.userid)
293 293
        self.assertEqual(response.status_code, 204)
294 294

  
295 295
        # Try to get the deleted meta: should raise 404
296
        response = self.get('/api/v1.1/servers/%d/meta/foo2' % vm.id,
296
        response = self.get('/api/v1.1/servers/%d/metadata/foo2' % vm.id,
297 297
                            vm.userid)
298 298
        self.assertEqual(response.status_code, 404)
299 299

  
300 300
    def test_invalid_metadata(self):
301 301
        vm = self.vm
302
        response = self.post('/api/v1.1/servers/%d/meta' % vm.id, vm.userid)
302
        response = self.post('/api/v1.1/servers/%d/metadata' % vm.id,
303
                             vm.userid)
303 304
        self.assertBadRequest(response)
304 305
        self.assertEqual(len(vm.metadata.all()), 1)
305 306

  
306 307
    def test_invalid_metadata_server(self):
307
        response = self.post('/api/v1.1/servers/42/meta', 'user')
308
        response = self.post('/api/v1.1/servers/42/metadata', 'user')
308 309
        self.assertItemNotFound(response)
309 310

  
310 311
    def test_get_meta_invalid_key(self):
311 312
        vm = self.vm
312
        response = self.get('/api/v1.1/servers/%d/meta/foo2' % vm.id,
313
        response = self.get('/api/v1.1/servers/%d/metadata/foo2' % vm.id,
313 314
                            vm.userid)
314 315
        self.assertItemNotFound(response)
315 316

  

Also available in: Unified diff