← Back to branch summary

~hudson-openstack/glance/milestone-proposed

« back to all changes in this revision

Viewing changes to tests/unit/test_api.py

  • Committer: Tarmac
  • Author(s): Brian Waldon, Yuriy Taraday, Justin Shepherd, Ewan Mellor, Thierry Carrez
  • Date: 2011-06-28 19:42:20 UTC
  • mfrom: (139.9.1 d2-merge)
  • Revision ID: tarmac-20110628194220-rhxw4nwelxeolztc
Merge diablo-2 development work

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unit/test_api.py
285
285
        for image in images:
286
286
            self.assertEqual('new name! #123', image['name'])
287
287
 
 
288
    def test_get_index_sort_default_created_at_desc(self):
 
289
        """
 
290
        Tests that the /images registry API returns list of
 
291
        public images that conforms to a default sort key/dir
 
292
        """
 
293
        time1 = datetime.datetime.utcnow() + datetime.timedelta(seconds=5)
 
294
        time2 = datetime.datetime.utcnow()
 
295
 
 
296
        extra_fixture = {'id': 3,
 
297
                         'status': 'active',
 
298
                         'is_public': True,
 
299
                         'disk_format': 'vhd',
 
300
                         'container_format': 'ovf',
 
301
                         'name': 'new name! #123',
 
302
                         'size': 19,
 
303
                         'checksum': None,
 
304
                         'created_at': time1}
 
305
 
 
306
        glance.registry.db.api.image_create(None, extra_fixture)
 
307
 
 
308
        extra_fixture = {'id': 4,
 
309
                         'status': 'active',
 
310
                         'is_public': True,
 
311
                         'disk_format': 'vhd',
 
312
                         'container_format': 'ovf',
 
313
                         'name': 'new name! #123',
 
314
                         'size': 20,
 
315
                         'checksum': None,
 
316
                         'created_at': time1}
 
317
 
 
318
        glance.registry.db.api.image_create(None, extra_fixture)
 
319
 
 
320
        extra_fixture = {'id': 5,
 
321
                         'status': 'active',
 
322
                         'is_public': True,
 
323
                         'disk_format': 'vhd',
 
324
                         'container_format': 'ovf',
 
325
                         'name': 'new name! #123',
 
326
                         'size': 20,
 
327
                         'checksum': None,
 
328
                         'created_at': time2}
 
329
 
 
330
        glance.registry.db.api.image_create(None, extra_fixture)
 
331
 
 
332
        req = webob.Request.blank('/images')
 
333
        res = req.get_response(self.api)
 
334
        res_dict = json.loads(res.body)
 
335
        self.assertEquals(res.status_int, 200)
 
336
 
 
337
        images = res_dict['images']
 
338
        self.assertEquals(len(images), 4)
 
339
        self.assertEquals(int(images[0]['id']), 4)
 
340
        self.assertEquals(int(images[1]['id']), 3)
 
341
        self.assertEquals(int(images[2]['id']), 5)
 
342
        self.assertEquals(int(images[3]['id']), 2)
 
343
 
 
344
    def test_get_index_bad_sort_key(self):
 
345
        """Ensure a 400 is returned when a bad sort_key is provided."""
 
346
        req = webob.Request.blank('/images?sort_key=asdf')
 
347
        res = req.get_response(self.api)
 
348
        self.assertEqual(400, res.status_int)
 
349
 
 
350
    def test_get_index_bad_sort_dir(self):
 
351
        """Ensure a 400 is returned when a bad sort_dir is provided."""
 
352
        req = webob.Request.blank('/images?sort_dir=asdf')
 
353
        res = req.get_response(self.api)
 
354
        self.assertEqual(400, res.status_int)
 
355
 
 
356
    def test_get_index_sort_id_desc(self):
 
357
        """
 
358
        Tests that the /images registry API returns list of
 
359
        public images sorted by id in descending order.
 
360
        """
 
361
        extra_fixture = {'id': 3,
 
362
                         'status': 'active',
 
363
                         'is_public': True,
 
364
                         'disk_format': 'vhd',
 
365
                         'container_format': 'ovf',
 
366
                         'name': 'asdf',
 
367
                         'size': 19,
 
368
                         'checksum': None}
 
369
 
 
370
        glance.registry.db.api.image_create(None, extra_fixture)
 
371
 
 
372
        extra_fixture = {'id': 4,
 
373
                         'status': 'active',
 
374
                         'is_public': True,
 
375
                         'disk_format': 'vhd',
 
376
                         'container_format': 'ovf',
 
377
                         'name': 'xyz',
 
378
                         'size': 20,
 
379
                         'checksum': None}
 
380
 
 
381
        glance.registry.db.api.image_create(None, extra_fixture)
 
382
 
 
383
        req = webob.Request.blank('/images?sort_key=id&sort_dir=desc')
 
384
        res = req.get_response(self.api)
 
385
        self.assertEquals(res.status_int, 200)
 
386
        res_dict = json.loads(res.body)
 
387
 
 
388
        images = res_dict['images']
 
389
        self.assertEquals(len(images), 3)
 
390
        self.assertEquals(int(images[0]['id']), 4)
 
391
        self.assertEquals(int(images[1]['id']), 3)
 
392
        self.assertEquals(int(images[2]['id']), 2)
 
393
 
 
394
    def test_get_index_sort_name_asc(self):
 
395
        """
 
396
        Tests that the /images registry API returns list of
 
397
        public images sorted alphabetically by name in
 
398
        ascending order.
 
399
        """
 
400
        extra_fixture = {'id': 3,
 
401
                         'status': 'active',
 
402
                         'is_public': True,
 
403
                         'disk_format': 'vhd',
 
404
                         'container_format': 'ovf',
 
405
                         'name': 'asdf',
 
406
                         'size': 19,
 
407
                         'checksum': None}
 
408
 
 
409
        glance.registry.db.api.image_create(None, extra_fixture)
 
410
 
 
411
        extra_fixture = {'id': 4,
 
412
                         'status': 'active',
 
413
                         'is_public': True,
 
414
                         'disk_format': 'vhd',
 
415
                         'container_format': 'ovf',
 
416
                         'name': 'xyz',
 
417
                         'size': 20,
 
418
                         'checksum': None}
 
419
 
 
420
        glance.registry.db.api.image_create(None, extra_fixture)
 
421
 
 
422
        req = webob.Request.blank('/images?sort_key=name&sort_dir=asc')
 
423
        res = req.get_response(self.api)
 
424
        self.assertEquals(res.status_int, 200)
 
425
        res_dict = json.loads(res.body)
 
426
 
 
427
        images = res_dict['images']
 
428
        self.assertEquals(len(images), 3)
 
429
        self.assertEquals(int(images[0]['id']), 3)
 
430
        self.assertEquals(int(images[1]['id']), 2)
 
431
        self.assertEquals(int(images[2]['id']), 4)
 
432
 
 
433
    def test_get_index_sort_status_desc(self):
 
434
        """
 
435
        Tests that the /images registry API returns list of
 
436
        public images sorted alphabetically by status in
 
437
        descending order.
 
438
        """
 
439
        extra_fixture = {'id': 3,
 
440
                         'status': 'killed',
 
441
                         'is_public': True,
 
442
                         'disk_format': 'vhd',
 
443
                         'container_format': 'ovf',
 
444
                         'name': 'asdf',
 
445
                         'size': 19,
 
446
                         'checksum': None}
 
447
 
 
448
        glance.registry.db.api.image_create(None, extra_fixture)
 
449
 
 
450
        extra_fixture = {'id': 4,
 
451
                         'status': 'active',
 
452
                         'is_public': True,
 
453
                         'disk_format': 'vhd',
 
454
                         'container_format': 'ovf',
 
455
                         'name': 'xyz',
 
456
                         'size': 20,
 
457
                         'checksum': None}
 
458
 
 
459
        glance.registry.db.api.image_create(None, extra_fixture)
 
460
 
 
461
        req = webob.Request.blank('/images?sort_key=status&sort_dir=desc')
 
462
        res = req.get_response(self.api)
 
463
        self.assertEquals(res.status_int, 200)
 
464
        res_dict = json.loads(res.body)
 
465
 
 
466
        images = res_dict['images']
 
467
        self.assertEquals(len(images), 3)
 
468
        self.assertEquals(int(images[0]['id']), 3)
 
469
        self.assertEquals(int(images[1]['id']), 4)
 
470
        self.assertEquals(int(images[2]['id']), 2)
 
471
 
 
472
    def test_get_index_sort_disk_format_asc(self):
 
473
        """
 
474
        Tests that the /images registry API returns list of
 
475
        public images sorted alphabetically by disk_format in
 
476
        ascending order.
 
477
        """
 
478
        extra_fixture = {'id': 3,
 
479
                         'status': 'active',
 
480
                         'is_public': True,
 
481
                         'disk_format': 'ami',
 
482
                         'container_format': 'ami',
 
483
                         'name': 'asdf',
 
484
                         'size': 19,
 
485
                         'checksum': None}
 
486
 
 
487
        glance.registry.db.api.image_create(None, extra_fixture)
 
488
 
 
489
        extra_fixture = {'id': 4,
 
490
                         'status': 'active',
 
491
                         'is_public': True,
 
492
                         'disk_format': 'vdi',
 
493
                         'container_format': 'ovf',
 
494
                         'name': 'xyz',
 
495
                         'size': 20,
 
496
                         'checksum': None}
 
497
 
 
498
        glance.registry.db.api.image_create(None, extra_fixture)
 
499
 
 
500
        req = webob.Request.blank('/images?sort_key=disk_format&sort_dir=asc')
 
501
        res = req.get_response(self.api)
 
502
        self.assertEquals(res.status_int, 200)
 
503
        res_dict = json.loads(res.body)
 
504
 
 
505
        images = res_dict['images']
 
506
        self.assertEquals(len(images), 3)
 
507
        self.assertEquals(int(images[0]['id']), 3)
 
508
        self.assertEquals(int(images[1]['id']), 4)
 
509
        self.assertEquals(int(images[2]['id']), 2)
 
510
 
 
511
    def test_get_index_sort_container_format_desc(self):
 
512
        """
 
513
        Tests that the /images registry API returns list of
 
514
        public images sorted alphabetically by container_format in
 
515
        descending order.
 
516
        """
 
517
        extra_fixture = {'id': 3,
 
518
                         'status': 'active',
 
519
                         'is_public': True,
 
520
                         'disk_format': 'ami',
 
521
                         'container_format': 'ami',
 
522
                         'name': 'asdf',
 
523
                         'size': 19,
 
524
                         'checksum': None}
 
525
 
 
526
        glance.registry.db.api.image_create(None, extra_fixture)
 
527
 
 
528
        extra_fixture = {'id': 4,
 
529
                         'status': 'active',
 
530
                         'is_public': True,
 
531
                         'disk_format': 'iso',
 
532
                         'container_format': 'bare',
 
533
                         'name': 'xyz',
 
534
                         'size': 20,
 
535
                         'checksum': None}
 
536
 
 
537
        glance.registry.db.api.image_create(None, extra_fixture)
 
538
 
 
539
        url = '/images?sort_key=container_format&sort_dir=desc'
 
540
        req = webob.Request.blank(url)
 
541
        res = req.get_response(self.api)
 
542
        self.assertEquals(res.status_int, 200)
 
543
        res_dict = json.loads(res.body)
 
544
 
 
545
        images = res_dict['images']
 
546
        self.assertEquals(len(images), 3)
 
547
        self.assertEquals(int(images[0]['id']), 2)
 
548
        self.assertEquals(int(images[1]['id']), 4)
 
549
        self.assertEquals(int(images[2]['id']), 3)
 
550
 
 
551
    def test_get_index_sort_size_asc(self):
 
552
        """
 
553
        Tests that the /images registry API returns list of
 
554
        public images sorted by size in ascending order.
 
555
        """
 
556
        extra_fixture = {'id': 3,
 
557
                         'status': 'active',
 
558
                         'is_public': True,
 
559
                         'disk_format': 'ami',
 
560
                         'container_format': 'ami',
 
561
                         'name': 'asdf',
 
562
                         'size': 100,
 
563
                         'checksum': None}
 
564
 
 
565
        glance.registry.db.api.image_create(None, extra_fixture)
 
566
 
 
567
        extra_fixture = {'id': 4,
 
568
                         'status': 'active',
 
569
                         'is_public': True,
 
570
                         'disk_format': 'iso',
 
571
                         'container_format': 'bare',
 
572
                         'name': 'xyz',
 
573
                         'size': 2,
 
574
                         'checksum': None}
 
575
 
 
576
        glance.registry.db.api.image_create(None, extra_fixture)
 
577
 
 
578
        url = '/images?sort_key=size&sort_dir=asc'
 
579
        req = webob.Request.blank(url)
 
580
        res = req.get_response(self.api)
 
581
        self.assertEquals(res.status_int, 200)
 
582
        res_dict = json.loads(res.body)
 
583
 
 
584
        images = res_dict['images']
 
585
        self.assertEquals(len(images), 3)
 
586
        self.assertEquals(int(images[0]['id']), 4)
 
587
        self.assertEquals(int(images[1]['id']), 2)
 
588
        self.assertEquals(int(images[2]['id']), 3)
 
589
 
 
590
    def test_get_index_sort_created_at_asc(self):
 
591
        """
 
592
        Tests that the /images registry API returns list of
 
593
        public images sorted by created_at in ascending order.
 
594
        """
 
595
        now = datetime.datetime.utcnow()
 
596
        time1 = now + datetime.timedelta(seconds=5)
 
597
        time2 = now
 
598
 
 
599
        extra_fixture = {'id': 3,
 
600
                         'status': 'active',
 
601
                         'is_public': True,
 
602
                         'disk_format': 'vhd',
 
603
                         'container_format': 'ovf',
 
604
                         'name': 'new name! #123',
 
605
                         'size': 19,
 
606
                         'checksum': None,
 
607
                         'created_at': time1}
 
608
 
 
609
        glance.registry.db.api.image_create(None, extra_fixture)
 
610
 
 
611
        extra_fixture = {'id': 4,
 
612
                         'status': 'active',
 
613
                         'is_public': True,
 
614
                         'disk_format': 'vhd',
 
615
                         'container_format': 'ovf',
 
616
                         'name': 'new name! #123',
 
617
                         'size': 20,
 
618
                         'checksum': None,
 
619
                         'created_at': time2}
 
620
 
 
621
        glance.registry.db.api.image_create(None, extra_fixture)
 
622
 
 
623
        req = webob.Request.blank('/images?sort_key=created_at&sort_dir=asc')
 
624
        res = req.get_response(self.api)
 
625
        self.assertEquals(res.status_int, 200)
 
626
        res_dict = json.loads(res.body)
 
627
 
 
628
        images = res_dict['images']
 
629
        self.assertEquals(len(images), 3)
 
630
        self.assertEquals(int(images[0]['id']), 2)
 
631
        self.assertEquals(int(images[1]['id']), 4)
 
632
        self.assertEquals(int(images[2]['id']), 3)
 
633
 
 
634
    def test_get_index_sort_updated_at_desc(self):
 
635
        """
 
636
        Tests that the /images registry API returns list of
 
637
        public images sorted by updated_at in descending order.
 
638
        """
 
639
        now = datetime.datetime.utcnow()
 
640
        time1 = now + datetime.timedelta(seconds=5)
 
641
        time2 = now
 
642
 
 
643
        extra_fixture = {'id': 3,
 
644
                         'status': 'active',
 
645
                         'is_public': True,
 
646
                         'disk_format': 'vhd',
 
647
                         'container_format': 'ovf',
 
648
                         'name': 'new name! #123',
 
649
                         'size': 19,
 
650
                         'checksum': None,
 
651
                         'created_at': None,
 
652
                         'created_at': time1}
 
653
 
 
654
        glance.registry.db.api.image_create(None, extra_fixture)
 
655
 
 
656
        extra_fixture = {'id': 4,
 
657
                         'status': 'active',
 
658
                         'is_public': True,
 
659
                         'disk_format': 'vhd',
 
660
                         'container_format': 'ovf',
 
661
                         'name': 'new name! #123',
 
662
                         'size': 20,
 
663
                         'checksum': None,
 
664
                         'created_at': None,
 
665
                         'updated_at': time2}
 
666
 
 
667
        glance.registry.db.api.image_create(None, extra_fixture)
 
668
 
 
669
        req = webob.Request.blank('/images?sort_key=updated_at&sort_dir=desc')
 
670
        res = req.get_response(self.api)
 
671
        self.assertEquals(res.status_int, 200)
 
672
        res_dict = json.loads(res.body)
 
673
 
 
674
        images = res_dict['images']
 
675
        self.assertEquals(len(images), 3)
 
676
        self.assertEquals(int(images[0]['id']), 3)
 
677
        self.assertEquals(int(images[1]['id']), 4)
 
678
        self.assertEquals(int(images[2]['id']), 2)
 
679
 
288
680
    def test_get_details(self):
289
681
        """Tests that the /images/detail registry API returns
290
682
        a mapping containing a list of detailed image information
668
1060
        for image in images:
669
1061
            self.assertEqual('v a', image['properties']['prop_123'])
670
1062
 
 
1063
    def test_get_details_sort_name_asc(self):
 
1064
        """
 
1065
        Tests that the /images/details registry API returns list of
 
1066
        public images sorted alphabetically by name in
 
1067
        ascending order.
 
1068
        """
 
1069
        extra_fixture = {'id': 3,
 
1070
                         'status': 'active',
 
1071
                         'is_public': True,
 
1072
                         'disk_format': 'vhd',
 
1073
                         'container_format': 'ovf',
 
1074
                         'name': 'asdf',
 
1075
                         'size': 19,
 
1076
                         'checksum': None}
 
1077
 
 
1078
        glance.registry.db.api.image_create(None, extra_fixture)
 
1079
 
 
1080
        extra_fixture = {'id': 4,
 
1081
                         'status': 'active',
 
1082
                         'is_public': True,
 
1083
                         'disk_format': 'vhd',
 
1084
                         'container_format': 'ovf',
 
1085
                         'name': 'xyz',
 
1086
                         'size': 20,
 
1087
                         'checksum': None}
 
1088
 
 
1089
        glance.registry.db.api.image_create(None, extra_fixture)
 
1090
 
 
1091
        req = webob.Request.blank('/images/detail?sort_key=name&sort_dir=asc')
 
1092
        res = req.get_response(self.api)
 
1093
        self.assertEquals(res.status_int, 200)
 
1094
        res_dict = json.loads(res.body)
 
1095
 
 
1096
        images = res_dict['images']
 
1097
        self.assertEquals(len(images), 3)
 
1098
        self.assertEquals(int(images[0]['id']), 3)
 
1099
        self.assertEquals(int(images[1]['id']), 2)
 
1100
        self.assertEquals(int(images[2]['id']), 4)
 
1101
 
671
1102
    def test_create_image(self):
672
1103
        """Tests that the /images POST registry API creates the image"""
673
1104
        fixture = {'name': 'fake public image',
678
1109
        req = webob.Request.blank('/images')
679
1110
 
680
1111
        req.method = 'POST'
 
1112
        req.content_type = 'application/json'
681
1113
        req.body = json.dumps(dict(image=fixture))
682
1114
 
683
1115
        res = req.get_response(self.api)
706
1138
        req = webob.Request.blank('/images')
707
1139
 
708
1140
        req.method = 'POST'
 
1141
        req.content_type = 'application/json'
709
1142
        req.body = json.dumps(dict(image=fixture))
710
1143
 
711
1144
        res = req.get_response(self.api)
723
1156
        req = webob.Request.blank('/images')
724
1157
 
725
1158
        req.method = 'POST'
 
1159
        req.content_type = 'application/json'
726
1160
        req.body = json.dumps(dict(image=fixture))
727
1161
 
728
1162
        res = req.get_response(self.api)
739
1173
        req = webob.Request.blank('/images')
740
1174
 
741
1175
        req.method = 'POST'
 
1176
        req.content_type = 'application/json'
742
1177
        req.body = json.dumps(dict(image=fixture))
743
1178
 
744
1179
        res = req.get_response(self.api)
758
1193
        req = webob.Request.blank('/images')
759
1194
 
760
1195
        req.method = 'POST'
 
1196
        req.content_type = 'application/json'
761
1197
        req.body = json.dumps(dict(image=fixture))
762
1198
 
763
1199
        res = req.get_response(self.api)
772
1208
        req = webob.Request.blank('/images/2')
773
1209
 
774
1210
        req.method = 'PUT'
 
1211
        req.content_type = 'application/json'
775
1212
        req.body = json.dumps(dict(image=fixture))
776
1213
 
777
1214
        res = req.get_response(self.api)
791
1228
        req = webob.Request.blank('/images/3')
792
1229
 
793
1230
        req.method = 'PUT'
 
1231
        req.content_type = 'application/json'
794
1232
        req.body = json.dumps(dict(image=fixture))
795
1233
 
796
1234
        res = req.get_response(self.api)
804
1242
        req = webob.Request.blank('/images/2')
805
1243
 
806
1244
        req.method = 'PUT'
 
1245
        req.content_type = 'application/json'
807
1246
        req.body = json.dumps(dict(image=fixture))
808
1247
 
809
1248
        res = req.get_response(self.api)
817
1256
        req = webob.Request.blank('/images/2')
818
1257
 
819
1258
        req.method = 'PUT'
 
1259
        req.content_type = 'application/json'
820
1260
        req.body = json.dumps(dict(image=fixture))
821
1261
 
822
1262
        res = req.get_response(self.api)
830
1270
        req = webob.Request.blank('/images/2')
831
1271
 
832
1272
        req.method = 'PUT'
 
1273
        req.content_type = 'application/json'
833
1274
        req.body = json.dumps(dict(image=fixture))
834
1275
 
835
1276
        res = req.get_response(self.api)
844
1285
        req = webob.Request.blank('/images/2')  # Image 2 has disk format 'vhd'
845
1286
 
846
1287
        req.method = 'PUT'
 
1288
        req.content_type = 'application/json'
847
1289
        req.body = json.dumps(dict(image=fixture))
848
1290
 
849
1291
        res = req.get_response(self.api)
972
1414
        res_body = json.loads(res.body)['image']
973
1415
        self.assertEquals('queued', res_body['status'])
974
1416
 
 
1417
    def test_add_image_no_location_no_content_type(self):
 
1418
        """Tests creates a queued image for no body and no loc header"""
 
1419
        fixture_headers = {'x-image-meta-store': 'file',
 
1420
                           'x-image-meta-disk-format': 'vhd',
 
1421
                           'x-image-meta-container-format': 'ovf',
 
1422
                           'x-image-meta-name': 'fake image #3'}
 
1423
 
 
1424
        req = webob.Request.blank("/images")
 
1425
        req.method = 'POST'
 
1426
        req.body = "chunk00000remainder"
 
1427
        for k, v in fixture_headers.iteritems():
 
1428
            req.headers[k] = v
 
1429
        res = req.get_response(self.api)
 
1430
        self.assertEquals(res.status_int, 400)
 
1431
 
975
1432
    def test_add_image_bad_store(self):
976
1433
        """Tests raises BadRequest for invalid store header"""
977
1434
        fixture_headers = {'x-image-meta-store': 'bad',
1016
1473
                        "res.headerlist = %r" % res.headerlist)
1017
1474
        self.assertTrue('/images/3' in res.headers['location'])
1018
1475
 
 
1476
    def test_get_index_sort_name_asc(self):
 
1477
        """
 
1478
        Tests that the /images registry API returns list of
 
1479
        public images sorted alphabetically by name in
 
1480
        ascending order.
 
1481
        """
 
1482
        extra_fixture = {'id': 3,
 
1483
                         'status': 'active',
 
1484
                         'is_public': True,
 
1485
                         'disk_format': 'vhd',
 
1486
                         'container_format': 'ovf',
 
1487
                         'name': 'asdf',
 
1488
                         'size': 19,
 
1489
                         'checksum': None}
 
1490
 
 
1491
        glance.registry.db.api.image_create(None, extra_fixture)
 
1492
 
 
1493
        extra_fixture = {'id': 4,
 
1494
                         'status': 'active',
 
1495
                         'is_public': True,
 
1496
                         'disk_format': 'vhd',
 
1497
                         'container_format': 'ovf',
 
1498
                         'name': 'xyz',
 
1499
                         'size': 20,
 
1500
                         'checksum': None}
 
1501
 
 
1502
        glance.registry.db.api.image_create(None, extra_fixture)
 
1503
 
 
1504
        req = webob.Request.blank('/images?sort_key=name&sort_dir=asc')
 
1505
        res = req.get_response(self.api)
 
1506
        self.assertEquals(res.status_int, 200)
 
1507
        res_dict = json.loads(res.body)
 
1508
 
 
1509
        images = res_dict['images']
 
1510
        self.assertEquals(len(images), 3)
 
1511
        self.assertEquals(int(images[0]['id']), 3)
 
1512
        self.assertEquals(int(images[1]['id']), 2)
 
1513
        self.assertEquals(int(images[2]['id']), 4)
 
1514
 
1019
1515
    def test_image_is_checksummed(self):
1020
1516
        """Test that the image contents are checksummed properly"""
1021
1517
        fixture_headers = {'x-image-meta-store': 'file',
1122
1618
    def test_show_image_basic(self):
1123
1619
        req = webob.Request.blank("/images/2")
1124
1620
        res = req.get_response(self.api)
 
1621
        self.assertEqual(res.status_int, 200)
 
1622
        self.assertEqual(res.content_type, 'application/octet-stream')
1125
1623
        self.assertEqual('chunk00000remainder', res.body)
1126
1624
 
1127
1625
    def test_show_non_exists_image(self):