← Back to branch summary

~ltrager/maas/lp1554636_2.0

« back to all changes in this revision

Viewing changes to src/maasserver/api/tests/test_blockdevice.py

Merge Blake's branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_blockdevice.py
6
6
__all__ = []
7
7
 
8
8
import http.client
9
 
import json
10
9
import uuid
11
10
 
 
11
from django.conf import settings
12
12
from django.core.urlresolvers import reverse
13
13
from maasserver.enum import (
14
14
    FILESYSTEM_FORMAT_TYPE_CHOICES,
20
20
from maasserver.testing.api import APITestCase
21
21
from maasserver.testing.factory import factory
22
22
from maasserver.testing.orm import reload_object
 
23
from maasserver.utils.converters import json_load_bytes
23
24
from testtools.matchers import (
24
25
    ContainsDict,
25
26
    Equals,
78
79
        self.assertEqual(
79
80
            http.client.OK, response.status_code, response.content)
80
81
 
81
 
        devices = json.loads(response.content)
 
82
        devices = json_load_bytes(response.content)
82
83
 
83
84
        # We should have four devices, three physical, one virtual.
84
85
        self.assertEqual(len(devices), 4)
103
104
 
104
105
        self.assertEqual(
105
106
            http.client.OK, response.status_code, response.content)
106
 
        parsed_devices = json.loads(response.content)
 
107
        parsed_devices = json_load_bytes(response.content)
107
108
        self.assertDictContainsSubset({
108
109
            "model": block_device.model,
109
110
            }, parsed_devices[0])
117
118
 
118
119
        self.assertEqual(
119
120
            http.client.OK, response.status_code, response.content)
120
 
        parsed_devices = json.loads(response.content)
 
121
        parsed_devices = json_load_bytes(response.content)
121
122
        self.assertDictContainsSubset({
122
123
            "fstype": filesystem.fstype,
123
124
            "uuid": filesystem.uuid,
135
136
 
136
137
        self.assertEqual(
137
138
            http.client.OK, response.status_code, response.content)
138
 
        parsed_devices = json.loads(response.content)
 
139
        parsed_devices = json_load_bytes(response.content)
139
140
 
140
141
        self.assertEqual(parsed_devices[0]['partition_table_type'],
141
142
                         partition_table.table_type)
157
158
 
158
159
        self.assertEqual(
159
160
            http.client.OK, response.status_code, response.content)
160
 
        parsed_devices = json.loads(response.content)
 
161
        parsed_devices = json_load_bytes(response.content)
161
162
 
162
163
        self.assertEqual(parsed_devices[0]['partition_table_type'], 'MBR')
163
164
        self.assertEqual(len(parsed_devices[0]['partitions']), 2)
189
190
 
190
191
        self.assertEqual(
191
192
            http.client.OK, response.status_code, response.content)
192
 
        parsed_devices = json.loads(response.content)
 
193
        parsed_devices = json_load_bytes(response.content)
193
194
 
194
195
        # We should have one device
195
196
        self.assertEqual(len(parsed_devices), 1)
269
270
 
270
271
        self.assertEqual(
271
272
            http.client.OK, response.status_code, response.content)
272
 
        parsed_device = json.loads(response.content)
 
273
        parsed_device = json_load_bytes(response.content)
273
274
        self.assertEqual(block_device.id, parsed_device["id"])
274
275
        self.assertEqual("physical", parsed_device["type"])
275
276
        self.assertEqual(
282
283
 
283
284
        self.assertEqual(
284
285
            http.client.OK, response.status_code, response.content)
285
 
        parsed_device = json.loads(response.content)
 
286
        parsed_device = json_load_bytes(response.content)
286
287
        self.assertEqual(block_device.id, parsed_device["id"])
287
288
 
288
289
    def test_read_virtual_block_device(self):
292
293
 
293
294
        self.assertEqual(
294
295
            http.client.OK, response.status_code, response.content)
295
 
        parsed_device = json.loads(response.content)
 
296
        parsed_device = json_load_bytes(response.content)
296
297
        self.assertEqual(block_device.id, parsed_device["id"])
297
298
        self.assertEqual(block_device.get_name(), parsed_device["name"])
298
299
        self.assertEqual("virtual", parsed_device["type"])
306
307
        response = self.client.get(uri)
307
308
        self.assertEqual(
308
309
            http.client.OK, response.status_code, response.content)
309
 
        parsed_device = json.loads(response.content)
 
310
        parsed_device = json_load_bytes(response.content)
310
311
        self.assertDictContainsSubset({
311
312
            "fstype": filesystem.fstype,
312
313
            "uuid": filesystem.uuid,
327
328
        response = self.client.get(uri)
328
329
        self.assertEqual(
329
330
            http.client.OK, response.status_code, response.content)
330
 
        parsed_device = json.loads(response.content)
 
331
        parsed_device = json_load_bytes(response.content)
331
332
        self.assertThat(
332
333
            parsed_device['partitions'][0],
333
334
            ContainsDict({
364
365
        response = self.client.get(uri)
365
366
        self.assertEqual(
366
367
            http.client.OK, response.status_code, response.content)
367
 
        parsed_device = json.loads(response.content)
 
368
        parsed_device = json_load_bytes(response.content)
368
369
        self.assertEqual({
369
370
            "fstype": filesystem1.fstype,
370
371
            "label": filesystem1.label,
454
455
 
455
456
        self.assertEqual(
456
457
            http.client.OK, response.status_code, response.content)
457
 
        parsed_device = json.loads(response.content)
 
458
        parsed_device = json_load_bytes(response.content)
458
459
        self.assertIn(tag_to_be_added, parsed_device['tags'])
459
460
        block_device = reload_object(block_device)
460
461
        self.assertIn(tag_to_be_added, block_device.tags)
502
503
 
503
504
        self.assertEqual(
504
505
            http.client.OK, response.status_code, response.content)
505
 
        parsed_device = json.loads(response.content)
 
506
        parsed_device = json_load_bytes(response.content)
506
507
        self.assertNotIn(tag_to_be_removed, parsed_device['tags'])
507
508
        block_device = reload_object(block_device)
508
509
        self.assertNotIn(tag_to_be_removed, block_device.tags)
543
544
 
544
545
        self.assertEqual(
545
546
            http.client.OK, response.status_code, response.content)
546
 
        parsed_device = json.loads(response.content)
 
547
        parsed_device = json_load_bytes(response.content)
547
548
        self.assertDictContainsSubset({
548
549
            'fstype': fstype,
549
550
            'uuid': fsuuid,
564
565
 
565
566
        self.assertEqual(
566
567
            http.client.OK, response.status_code, response.content)
567
 
        parsed_device = json.loads(response.content)
 
568
        parsed_device = json_load_bytes(response.content)
568
569
        self.assertDictContainsSubset({
569
570
            'fstype': fstype,
570
571
            'uuid': fsuuid,
605
606
 
606
607
        self.assertEqual(
607
608
            http.client.BAD_REQUEST, response.status_code, response.content)
608
 
        self.assertEqual("Block device is not formatted.", response.content)
 
609
        self.assertEqual(b"Block device is not formatted.", response.content)
609
610
 
610
611
    def test_unformat_returns_400_if_mounted(self):
611
612
        self.become_admin()
619
620
        self.assertEqual(
620
621
            http.client.BAD_REQUEST, response.status_code, response.content)
621
622
        self.assertEqual(
622
 
            "Filesystem is mounted and cannot be unformatted. Unmount the "
623
 
            "filesystem before unformatting the block device.",
 
623
            b"Filesystem is mounted and cannot be unformatted. Unmount the "
 
624
            b"filesystem before unformatting the block device.",
624
625
            response.content)
625
626
 
626
627
    def test_unformat_returns_400_if_in_filesystem_group(self):
638
639
 
639
640
        self.assertEqual(
640
641
            http.client.BAD_REQUEST, response.status_code, response.content)
641
 
        self.assertEqual(
 
642
        expected = (
642
643
            "Filesystem is part of a %s, and cannot be "
643
644
            "unformatted. Remove block device from %s "
644
645
            "before unformatting the block device." % (
645
 
                fsgroup.get_nice_name(), fsgroup.get_nice_name()),
 
646
                fsgroup.get_nice_name(), fsgroup.get_nice_name()))
 
647
        self.assertEqual(
 
648
            expected.encode(settings.DEFAULT_CHARSET),
646
649
            response.content)
647
650
 
648
651
    def test_unformat_deletes_filesystem_as_admin(self):
656
659
 
657
660
        self.assertEqual(
658
661
            http.client.OK, response.status_code, response.content)
659
 
        parsed_device = json.loads(response.content)
 
662
        parsed_device = json_load_bytes(response.content)
660
663
        self.assertIsNone(parsed_device["filesystem"])
661
664
        block_device = reload_object(block_device)
662
665
        self.assertIsNone(block_device.get_effective_filesystem())
672
675
 
673
676
        self.assertEqual(
674
677
            http.client.OK, response.status_code, response.content)
675
 
        parsed_device = json.loads(response.content)
 
678
        parsed_device = json_load_bytes(response.content)
676
679
        self.assertIsNone(parsed_device["filesystem"])
677
680
        block_device = reload_object(block_device)
678
681
        self.assertIsNone(block_device.get_effective_filesystem())
711
714
 
712
715
        self.assertEqual(
713
716
            http.client.OK, response.status_code, response.content)
714
 
        parsed_device = json.loads(response.content)
 
717
        parsed_device = json_load_bytes(response.content)
715
718
        self.assertEqual(
716
719
            mount_point, parsed_device['filesystem']['mount_point'])
717
720
        self.assertEqual(
730
733
 
731
734
        self.assertEqual(
732
735
            http.client.OK, response.status_code, response.content)
733
 
        parsed_device = json.loads(response.content)
 
736
        parsed_device = json_load_bytes(response.content)
734
737
        self.assertEqual(
735
738
            mount_point, parsed_device['filesystem']['mount_point'])
736
739
        self.assertEqual(
769
772
 
770
773
        self.assertEqual(
771
774
            http.client.BAD_REQUEST, response.status_code, response.content)
772
 
        parsed_error = json.loads(response.content)
 
775
        parsed_error = json_load_bytes(response.content)
773
776
        self.assertEqual(
774
777
            {"mount_point": ["This field is required."]},
775
778
            parsed_error)
785
788
        self.assertEqual(
786
789
            http.client.BAD_REQUEST, response.status_code, response.content)
787
790
        self.assertEqual(
788
 
            "Block device is not formatted.", response.content)
 
791
            b"Block device is not formatted.", response.content)
789
792
 
790
793
    def test_unmount_returns_400_if_already_unmounted(self):
791
794
        self.become_admin()
799
802
        self.assertEqual(
800
803
            http.client.BAD_REQUEST, response.status_code, response.content)
801
804
        self.assertEqual(
802
 
            "Filesystem is already unmounted.", response.content)
 
805
            b"Filesystem is already unmounted.", response.content)
803
806
 
804
807
    def test_unmount_unmounts_filesystem_as_admin(self):
805
808
        self.become_admin()
814
817
        self.assertEqual(
815
818
            http.client.OK, response.status_code, response.content)
816
819
        self.assertIsNone(
817
 
            json.loads(response.content)['filesystem']['mount_point'])
 
820
            json_load_bytes(response.content)['filesystem']['mount_point'])
818
821
        self.assertIsNone(
819
822
            reload_object(filesystem).mount_point)
820
823
 
831
834
        self.assertEqual(
832
835
            http.client.OK, response.status_code, response.content)
833
836
        self.assertIsNone(
834
 
            json.loads(response.content)['filesystem']['mount_point'])
 
837
            json_load_bytes(response.content)['filesystem']['mount_point'])
835
838
        self.assertIsNone(
836
839
            reload_object(filesystem).mount_point)
837
840
 
856
859
        block_device = reload_object(block_device)
857
860
        self.assertEqual(
858
861
            http.client.OK, response.status_code, response.content)
859
 
        parsed_device = json.loads(response.content)
 
862
        parsed_device = json_load_bytes(response.content)
860
863
        self.assertEqual(parsed_device['id'], block_device.id)
861
864
        self.assertEqual('mynewname', parsed_device['name'])
862
865
        self.assertEqual(4096, parsed_device['block_size'])
881
884
        block_device = reload_object(block_device)
882
885
        self.assertEqual(
883
886
            http.client.OK, response.status_code, response.content)
884
 
        parsed_device = json.loads(response.content)
 
887
        parsed_device = json_load_bytes(response.content)
885
888
        self.assertEqual(block_device.id, parsed_device['id'])
886
889
        self.assertEqual(name, parsed_device['name'])
887
890