← Back to branch summary

~ltrager/maas/lp1554636_2.0

« back to all changes in this revision

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

Merge Blake's branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_enlistment.py
8
8
import http.client
9
9
import json
10
10
 
 
11
from django.conf import settings
11
12
from django.contrib.auth.models import AnonymousUser
12
13
from django.core.urlresolvers import reverse
13
14
from maasserver.enum import (
29
30
from maasserver.testing.orm import reload_object
30
31
from maasserver.testing.testcase import MAASServerTestCase
31
32
from maasserver.utils import strip_domain
 
33
from maasserver.utils.converters import json_load_bytes
32
34
from maasserver.utils.orm import get_one
33
35
from netaddr import IPNetwork
34
36
 
63
65
            })
64
66
 
65
67
        self.assertEqual(http.client.OK, response.status_code)
66
 
        parsed_result = json.loads(response.content)
 
68
        parsed_result = json_load_bytes(response.content)
67
69
        self.assertIn('application/json', response['Content-Type'])
68
70
        nodegroup = NodeGroup.objects.ensure_master()
69
71
        domain_name = nodegroup.name
86
88
                'power_type': 'ether_wake',
87
89
                'mac_addresses': [factory.make_mac_address()],
88
90
            })
89
 
        parsed_result = json.loads(response.content)
 
91
        parsed_result = json_load_bytes(response.content)
90
92
 
91
93
        self.assertEqual(http.client.OK, response.status_code)
92
94
        system_id = parsed_result.get('system_id')
135
137
            })
136
138
 
137
139
        self.assertEqual(http.client.OK, response.status_code)
138
 
        parsed_result = json.loads(response.content)
 
140
        parsed_result = json_load_bytes(response.content)
139
141
        self.assertIn('application/json', response['Content-Type'])
140
142
        nodegroup = NodeGroup.objects.ensure_master()
141
143
        domain_name = nodegroup.name
161
163
            })
162
164
 
163
165
        self.assertEqual(http.client.OK, response.status_code)
164
 
        parsed_result = json.loads(response.content)
 
166
        parsed_result = json_load_bytes(response.content)
165
167
        self.assertIn('application/json', response['Content-Type'])
166
168
        nodegroup = NodeGroup.objects.ensure_master()
167
169
        domain_name = nodegroup.name
186
188
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
187
189
        self.assertIn('text/plain', response['Content-Type'])
188
190
        self.assertEqual(
189
 
            "Subarchitecture cannot be specified twice.",
 
191
            b"Subarchitecture cannot be specified twice.",
190
192
            response.content)
191
193
 
192
194
    def test_POST_new_associates_mac_addresses(self):
234
236
                'mac_addresses': [factory.make_mac_address()],
235
237
            })
236
238
        node = Node.objects.get(
237
 
            system_id=json.loads(response.content)['system_id'])
 
239
            system_id=json_load_bytes(response.content)['system_id'])
238
240
        self.assertNotEqual("", strip_domain(node.hostname))
239
241
 
240
242
    def test_POST_fails_without_operation(self):
250
252
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
251
253
        self.assertIn('text/plain', response['Content-Type'])
252
254
        self.assertEqual(
253
 
            "Unrecognised signature: method=POST op=None",
 
255
            b"Unrecognised signature: method=POST op=None",
254
256
            response.content)
255
257
 
256
258
    def test_POST_new_fails_if_autodetect_nodegroup_required(self):
270
272
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
271
273
        self.assertIn('text/plain', response['Content-Type'])
272
274
        self.assertEqual(
273
 
            "'autodetect_nodegroup' must be specified if 'nodegroup' "
274
 
            "parameter missing", response.content)
 
275
            b"'autodetect_nodegroup' must be specified if 'nodegroup' "
 
276
            b"parameter missing", response.content)
275
277
 
276
278
    def test_POST_fails_if_mac_duplicated(self):
277
279
        # Mac Addresses should be unique.
287
289
                'hostname': factory.make_string(),
288
290
                'mac_addresses': [mac],
289
291
            })
290
 
        parsed_result = json.loads(response.content)
 
292
        parsed_result = json_load_bytes(response.content)
291
293
 
292
294
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
293
295
        self.assertIn('application/json', response['Content-Type'])
309
311
 
310
312
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
311
313
        self.assertEqual(
312
 
            "Unrecognised signature: method=POST op=invalid_operation",
 
314
            b"Unrecognised signature: method=POST op=invalid_operation",
313
315
            response.content)
314
316
 
315
317
    def test_POST_new_rejects_invalid_data(self):
323
325
                'hostname': 'diane',
324
326
                'mac_addresses': ['aa:bb:cc:dd:ee:ff', 'invalid'],
325
327
            })
326
 
        parsed_result = json.loads(response.content)
 
328
        parsed_result = json_load_bytes(response.content)
327
329
 
328
330
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
329
331
        self.assertIn('application/json', response['Content-Type'])
346
348
                'mac_addresses': ['aa:bb:cc:dd:ee:ff'],
347
349
                'architecture': 'invalid-architecture',
348
350
            })
349
 
        parsed_result = json.loads(response.content)
 
351
        parsed_result = json_load_bytes(response.content)
350
352
 
351
353
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
352
354
        self.assertIn('application/json', response['Content-Type'])
391
393
            })
392
394
        self.assertEqual(
393
395
            http.client.OK, response.status_code, response.content)
394
 
        parsed_result = json.loads(response.content)
 
396
        parsed_result = json_load_bytes(response.content)
395
397
        expected_hostname = '%s.%s' % (hostname_without_domain, domain)
396
398
        self.assertEqual(
397
399
            expected_hostname, parsed_result.get('hostname'))
415
417
            })
416
418
        self.assertEqual(
417
419
            http.client.OK, response.status_code, response.content)
418
 
        parsed_result = json.loads(response.content)
 
420
        parsed_result = json_load_bytes(response.content)
419
421
        expected_hostname = '%s.%s' % (hostname_without_domain, domain)
420
422
        self.assertEqual(
421
423
            expected_hostname, parsed_result.get('hostname'))
440
442
            REMOTE_ADDR=origin_ip)
441
443
        self.assertEqual(
442
444
            http.client.OK, response.status_code, response.content)
443
 
        parsed_result = json.loads(response.content)
 
445
        parsed_result = json_load_bytes(response.content)
444
446
        node = Node.objects.get(system_id=parsed_result.get('system_id'))
445
447
        self.assertEqual(nodegroup, node.nodegroup)
446
448
 
459
461
            HTTP_HOST=unknown_host)
460
462
        self.assertEqual(
461
463
            http.client.OK, response.status_code, response.content)
462
 
        parsed_result = json.loads(response.content)
 
464
        parsed_result = json_load_bytes(response.content)
463
465
        node = Node.objects.get(system_id=parsed_result.get('system_id'))
464
466
        self.assertEqual(NodeGroup.objects.ensure_master(), node.nodegroup)
465
467
 
494
496
            })
495
497
        self.assertEqual(
496
498
            http.client.OK, response.status_code, response.content)
497
 
        system_id = json.loads(response.content)['system_id']
 
499
        system_id = json_load_bytes(response.content)['system_id']
498
500
        self.assertEqual(
499
501
            NODE_STATUS.NEW,
500
502
            Node.objects.get(system_id=system_id).status)
518
520
            reverse('nodes_handler'), {'op': 'accept', 'nodes': [node_id]})
519
521
        self.assertEqual(
520
522
            (http.client.UNAUTHORIZED,
521
 
             "You must be logged in to accept nodes."),
 
523
             b"You must be logged in to accept nodes."),
522
524
            (response.status_code, response.content))
523
525
 
524
526
    def test_POST_returns_limited_fields(self):
531
533
                'hostname': factory.make_string(),
532
534
                'mac_addresses': ['aa:bb:cc:dd:ee:ff', '22:bb:cc:dd:ee:ff'],
533
535
            })
534
 
        parsed_result = json.loads(response.content)
 
536
        parsed_result = json_load_bytes(response.content)
535
537
        self.assertItemsEqual(
536
538
            [
537
539
                'hostname',
587
589
        response = self.client.post(
588
590
            reverse('nodes_handler'), {'op': 'accept', 'nodes': [node_id]})
589
591
        self.assertEqual(
590
 
            (http.client.FORBIDDEN,
 
592
            (http.client.FORBIDDEN, (
591
593
                "You don't have the required permission to accept the "
592
 
                "following node(s): %s." % node_id),
 
594
                "following node(s): %s." % node_id).encode(
 
595
                settings.DEFAULT_CHARSET)),
593
596
            (response.status_code, response.content))
594
597
 
595
598
    def test_POST_accept_all_does_not_accept_anything(self):
603
606
        response = self.client.post(
604
607
            reverse('nodes_handler'), {'op': 'accept_all'})
605
608
        self.assertEqual(http.client.OK, response.status_code)
606
 
        nodes_returned = json.loads(response.content)
 
609
        nodes_returned = json_load_bytes(response.content)
607
610
        self.assertEqual([], nodes_returned)
608
611
 
609
612
    def test_POST_simple_user_can_set_power_type_and_parameters(self):
621
624
                })
622
625
 
623
626
        node = Node.objects.get(
624
 
            system_id=json.loads(response.content)['system_id'])
 
627
            system_id=json_load_bytes(response.content)['system_id'])
625
628
        self.assertEqual(
626
629
            (http.client.OK, {"power_address": new_power_address},
627
630
             'ether_wake'),
639
642
                'architecture': make_usable_architecture(self),
640
643
                'mac_addresses': ['aa:bb:cc:dd:ee:ff', '22:bb:cc:dd:ee:ff'],
641
644
            })
642
 
        parsed_result = json.loads(response.content)
 
645
        parsed_result = json_load_bytes(response.content)
643
646
        self.assertItemsEqual(
644
647
            [
645
648
                'hostname',
701
704
                'mac_addresses': ['00:11:22:33:44:55'],
702
705
                })
703
706
        node = Node.objects.get(
704
 
            system_id=json.loads(response.content)['system_id'])
 
707
            system_id=json_load_bytes(response.content)['system_id'])
705
708
        self.assertEqual('ether_wake', node.power_type)
706
709
        self.assertEqual('', node.power_parameters)
707
710
 
723
726
        self.assertEqual(
724
727
            http.client.OK, response.status_code, response.content)
725
728
        node = Node.objects.get(
726
 
            system_id=json.loads(response.content)['system_id'])
 
729
            system_id=json_load_bytes(response.content)['system_id'])
727
730
        self.assertEqual(
728
731
            {'mac_address': new_mac_address},
729
732
            reload_object(node).power_parameters)
747
750
                http.client.BAD_REQUEST,
748
751
                {'power_parameters': ["Unknown parameter(s): unknown_param."]}
749
752
            ),
750
 
            (response.status_code, json.loads(response.content)))
 
753
            (response.status_code, json_load_bytes(response.content)))
751
754
        self.assertFalse(Node.objects.filter(hostname=hostname).exists())
752
755
 
753
756
    def test_POST_new_sets_power_parameters_skip_check(self):
769
772
        self.assertEqual(
770
773
            http.client.OK, response.status_code, response.content)
771
774
        node = Node.objects.get(
772
 
            system_id=json.loads(response.content)['system_id'])
 
775
            system_id=json_load_bytes(response.content)['system_id'])
773
776
        self.assertEqual(
774
777
            {'param': param},
775
778
            reload_object(node).power_parameters)
789
792
                'mac_addresses': ['aa:bb:cc:dd:ee:ff'],
790
793
            })
791
794
        self.assertEqual(http.client.OK, response.status_code)
792
 
        system_id = json.loads(response.content)['system_id']
 
795
        system_id = json_load_bytes(response.content)['system_id']
793
796
        self.assertEqual(
794
797
            NODE_STATUS.COMMISSIONING,
795
798
            Node.objects.get(system_id=system_id).status)
806
809
                'power_type': 'ether_wake',
807
810
                'mac_addresses': ['aa:bb:cc:dd:ee:ff', '22:bb:cc:dd:ee:ff'],
808
811
            })
809
 
        parsed_result = json.loads(response.content)
 
812
        parsed_result = json_load_bytes(response.content)
810
813
        self.assertItemsEqual(
811
814
            [
812
815
                'hostname',
856
859
        response = self.client.post(
857
860
            reverse('nodes_handler'), {'op': 'accept_all'})
858
861
        self.assertEqual(http.client.OK, response.status_code)
859
 
        nodes_returned = json.loads(response.content)
 
862
        nodes_returned = json_load_bytes(response.content)
860
863
        self.assertSetEqual(
861
864
            {node.system_id for node in nodes},
862
865
            {node["system_id"] for node in nodes_returned})