← Back to branch summary

~rvb/maas/transaction-1.7-bug-1409852

« back to all changes in this revision

Viewing changes to src/metadataserver/tests/test_api.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/metadataserver/tests/test_api.py
107
107
        self.assertRaises(UnknownMetadataVersion, check_version, '1.0')
108
108
 
109
109
    def test_get_node_for_request_finds_node(self):
110
 
        node = factory.make_node()
 
110
        node = factory.make_Node()
111
111
        token = NodeKey.objects.get_token_for_node(node)
112
112
        request = self.fake_request(
113
113
            HTTP_AUTHORIZATION=factory.make_oauth_header(
129
129
            MAASAPINotFound, get_node_for_mac, factory.getRandomMACAddress())
130
130
 
131
131
    def test_get_node_for_mac_finds_node_by_mac(self):
132
 
        mac = factory.make_mac_address()
 
132
        mac = factory.make_MACAddress()
133
133
        self.assertEqual(mac.node, get_node_for_mac(mac.mac_address))
134
134
 
135
135
    def test_get_queried_node_looks_up_by_mac_if_given(self):
136
 
        mac = factory.make_mac_address()
 
136
        mac = factory.make_MACAddress()
137
137
        self.assertEqual(
138
138
            mac.node,
139
139
            get_queried_node(object(), for_mac=mac.mac_address))
140
140
 
141
141
    def test_get_queried_node_looks_up_oauth_key_by_default(self):
142
 
        node = factory.make_node()
 
142
        node = factory.make_Node()
143
143
        token = NodeKey.objects.get_token_for_node(node)
144
144
        request = self.fake_request(
145
145
            HTTP_AUTHORIZATION=factory.make_oauth_header(
150
150
def make_node_client(node=None):
151
151
    """Create a test client logged in as if it were `node`."""
152
152
    if node is None:
153
 
        node = factory.make_node()
 
153
        node = factory.make_Node()
154
154
    token = NodeKey.objects.get_token_for_node(node)
155
155
    return OAuthAuthenticatedClient(get_node_init_user(), token)
156
156
 
167
167
        to the "signal" call.
168
168
    """
169
169
    if client is None:
170
 
        client = make_node_client(factory.make_node(
 
170
        client = make_node_client(factory.make_Node(
171
171
            status=NODE_STATUS.COMMISSIONING))
172
172
    params = {
173
173
        'op': 'signal',
241
241
        self.assertNotIn('user-data', items)
242
242
 
243
243
    def test_version_index_shows_user_data_if_available(self):
244
 
        node = factory.make_node()
 
244
        node = factory.make_Node()
245
245
        NodeUserData.objects.set_user_data(node, b"User data for node")
246
246
        client = make_node_client(node)
247
247
        view_name = self.get_metadata_name('-version')
252
252
    def test_meta_data_view_lists_fields(self):
253
253
        # Some fields only are returned if there is data related to them.
254
254
        user, _ = factory.make_user_with_keys(n_keys=2, username='my-user')
255
 
        node = factory.make_node(owner=user)
 
255
        node = factory.make_Node(owner=user)
256
256
        client = make_node_client(node=node)
257
257
        view_name = self.get_metadata_name('-meta-data')
258
258
        url = reverse(view_name, args=['latest', ''])
282
282
        self.assertNotIn(None, producers)
283
283
 
284
284
    def test_meta_data_local_hostname_returns_fqdn(self):
285
 
        nodegroup = factory.make_node_group(
 
285
        nodegroup = factory.make_NodeGroup(
286
286
            status=NODEGROUP_STATUS.ACCEPTED,
287
287
            management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
288
288
        hostname = factory.make_string()
289
289
        domain = factory.make_string()
290
 
        node = factory.make_node(
 
290
        node = factory.make_Node(
291
291
            hostname='%s.%s' % (hostname, domain), nodegroup=nodegroup)
292
292
        client = make_node_client(node)
293
293
        view_name = self.get_metadata_name('-meta-data')
299
299
        self.assertIn('text/plain', response['Content-Type'])
300
300
 
301
301
    def test_meta_data_instance_id_returns_system_id(self):
302
 
        node = factory.make_node()
 
302
        node = factory.make_Node()
303
303
        client = make_node_client(node)
304
304
        view_name = self.get_metadata_name('-meta-data')
305
305
        url = reverse(view_name, args=['latest', 'instance-id'])
319
319
 
320
320
    def test_public_keys_listed_for_node_with_public_keys(self):
321
321
        user, _ = factory.make_user_with_keys(n_keys=2, username='my-user')
322
 
        node = factory.make_node(owner=user)
 
322
        node = factory.make_Node(owner=user)
323
323
        view_name = self.get_metadata_name('-meta-data')
324
324
        url = reverse(view_name, args=['latest', ''])
325
325
        client = make_node_client(node=node)
338
338
 
339
339
    def test_public_keys_for_node_returns_list_of_keys(self):
340
340
        user, _ = factory.make_user_with_keys(n_keys=2, username='my-user')
341
 
        node = factory.make_node(owner=user)
 
341
        node = factory.make_Node(owner=user)
342
342
        view_name = self.get_metadata_name('-meta-data')
343
343
        url = reverse(view_name, args=['latest', 'public-keys'])
344
344
        client = make_node_client(node=node)
355
355
        # The metadata service also accepts urls with any number of additional
356
356
        # slashes after 'metadata': e.g. http://host/metadata///rest-of-url.
357
357
        user, _ = factory.make_user_with_keys(n_keys=2, username='my-user')
358
 
        node = factory.make_node(owner=user)
 
358
        node = factory.make_Node(owner=user)
359
359
        view_name = self.get_metadata_name('-meta-data')
360
360
        url = reverse(view_name, args=['latest', 'public-keys'])
361
361
        # Insert additional slashes.
372
372
    """Tests for the metadata user-data API endpoint."""
373
373
 
374
374
    def test_user_data_view_returns_binary_data(self):
375
 
        node = factory.make_node()
 
375
        node = factory.make_Node()
376
376
        NodeUserData.objects.set_user_data(node, sample_binary_data)
377
377
        client = make_node_client(node)
378
378
        response = client.get(reverse('metadata-user-data', args=['latest']))
394
394
    def test_request_does_not_cause_status_change_if_not_deploying(self):
395
395
        status = factory.pick_enum(
396
396
            NODE_STATUS, but_not=[NODE_STATUS.DEPLOYING])
397
 
        node = factory.make_node(status=status)
 
397
        node = factory.make_Node(status=status)
398
398
        NodeUserData.objects.set_user_data(node, sample_binary_data)
399
399
        client = make_node_client(node)
400
400
        response = client.get(reverse('metadata-user-data', args=['latest']))
402
402
        self.assertEqual(status, reload_object(node).status)
403
403
 
404
404
    def test_request_causes_status_change_if_deploying(self):
405
 
        node = factory.make_node(status=NODE_STATUS.DEPLOYING)
 
405
        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
406
406
        NodeUserData.objects.set_user_data(node, sample_binary_data)
407
407
        client = make_node_client(node)
408
408
        response = client.get(reverse('metadata-user-data', args=['latest']))
414
414
    """Tests for the curtin-metadata user-data API endpoint."""
415
415
 
416
416
    def test_curtin_user_data_view_returns_curtin_data(self):
417
 
        node = factory.make_node(nodegroup=self.rpc_nodegroup)
418
 
        factory.make_node_group_interface(
 
417
        node = factory.make_Node(nodegroup=self.rpc_nodegroup)
 
418
        factory.make_NodeGroupInterface(
419
419
            node.nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
420
420
        arch, subarch = node.architecture.split('/')
421
 
        factory.make_boot_image(
 
421
        factory.make_BootImage(
422
422
            osystem=node.get_osystem(),
423
423
            architecture=arch, subarchitecture=subarch,
424
424
            release=node.get_distro_series(), purpose='xinstall',
435
435
class TestInstallingAPI(MAASServerTestCase):
436
436
 
437
437
    def test_other_user_than_node_cannot_signal_installing_result(self):
438
 
        node = factory.make_node(status=NODE_STATUS.DEPLOYING)
439
 
        client = OAuthAuthenticatedClient(factory.make_user())
 
438
        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
 
439
        client = OAuthAuthenticatedClient(factory.make_User())
440
440
        response = call_signal(client)
441
441
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
442
442
        self.assertEqual(
443
443
            NODE_STATUS.DEPLOYING, reload_object(node).status)
444
444
 
445
445
    def test_signaling_installing_result_does_not_affect_other_node(self):
446
 
        node = factory.make_node(status=NODE_STATUS.DEPLOYING)
 
446
        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
447
447
        client = make_node_client(
448
 
            node=factory.make_node(status=NODE_STATUS.DEPLOYING))
 
448
            node=factory.make_Node(status=NODE_STATUS.DEPLOYING))
449
449
        response = call_signal(client, status='OK')
450
450
        self.assertEqual(httplib.OK, response.status_code)
451
451
        self.assertEqual(
452
452
            NODE_STATUS.DEPLOYING, reload_object(node).status)
453
453
 
454
454
    def test_signaling_installing_success_leaves_node_deploying(self):
455
 
        node = factory.make_node(status=NODE_STATUS.DEPLOYING)
 
455
        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
456
456
        client = make_node_client(node=node)
457
457
        response = call_signal(client, status='OK')
458
458
        self.assertEqual(httplib.OK, response.status_code)
459
459
        self.assertEqual(NODE_STATUS.DEPLOYING, reload_object(node).status)
460
460
 
461
461
    def test_signaling_installing_success_is_idempotent(self):
462
 
        node = factory.make_node(status=NODE_STATUS.DEPLOYING)
 
462
        node = factory.make_Node(status=NODE_STATUS.DEPLOYING)
463
463
        client = make_node_client(node=node)
464
464
        call_signal(client, status='OK')
465
465
        response = call_signal(client, status='OK')
467
467
        self.assertEqual(NODE_STATUS.DEPLOYING, reload_object(node).status)
468
468
 
469
469
    def test_signaling_installing_success_does_not_clear_owner(self):
470
 
        node = factory.make_node(
471
 
            status=NODE_STATUS.DEPLOYING, owner=factory.make_user())
 
470
        node = factory.make_Node(
 
471
            status=NODE_STATUS.DEPLOYING, owner=factory.make_User())
472
472
        client = make_node_client(node=node)
473
473
        response = call_signal(client, status='OK')
474
474
        self.assertEqual(httplib.OK, response.status_code)
475
475
        self.assertEqual(node.owner, reload_object(node).owner)
476
476
 
477
477
    def test_signaling_installing_failure_makes_node_failed(self):
478
 
        node = factory.make_node(
479
 
            status=NODE_STATUS.DEPLOYING, owner=factory.make_user())
 
478
        node = factory.make_Node(
 
479
            status=NODE_STATUS.DEPLOYING, owner=factory.make_User())
480
480
        client = make_node_client(node=node)
481
481
        response = call_signal(client, status='FAILED')
482
482
        self.assertEqual(httplib.OK, response.status_code)
484
484
            NODE_STATUS.FAILED_DEPLOYMENT, reload_object(node).status)
485
485
 
486
486
    def test_signaling_installing_failure_is_idempotent(self):
487
 
        node = factory.make_node(
488
 
            status=NODE_STATUS.DEPLOYING, owner=factory.make_user())
 
487
        node = factory.make_Node(
 
488
            status=NODE_STATUS.DEPLOYING, owner=factory.make_User())
489
489
        client = make_node_client(node=node)
490
490
        call_signal(client, status='FAILED')
491
491
        response = call_signal(client, status='FAILED')
497
497
class TestCommissioningAPI(MAASServerTestCase):
498
498
 
499
499
    def test_commissioning_scripts(self):
500
 
        script = factory.make_commissioning_script()
 
500
        script = factory.make_CommissioningScript()
501
501
        response = make_node_client().get(
502
502
            reverse('commissioning-scripts', args=['latest']))
503
503
        self.assertEqual(
518
518
            archive.getnames())
519
519
 
520
520
    def test_other_user_than_node_cannot_signal_commissioning_result(self):
521
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
522
 
        client = OAuthAuthenticatedClient(factory.make_user())
 
521
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
 
522
        client = OAuthAuthenticatedClient(factory.make_User())
523
523
        response = call_signal(client)
524
524
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
525
525
        self.assertEqual(
526
526
            NODE_STATUS.COMMISSIONING, reload_object(node).status)
527
527
 
528
528
    def test_signaling_commissioning_result_does_not_affect_other_node(self):
529
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
529
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
530
530
        client = make_node_client(
531
 
            node=factory.make_node(status=NODE_STATUS.COMMISSIONING))
 
531
            node=factory.make_Node(status=NODE_STATUS.COMMISSIONING))
532
532
        response = call_signal(client, status='OK')
533
533
        self.assertEqual(httplib.OK, response.status_code)
534
534
        self.assertEqual(
537
537
    def test_signaling_commissioning_OK_repopulates_tags(self):
538
538
        populate_tags_for_single_node = self.patch(
539
539
            api, "populate_tags_for_single_node")
540
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
540
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
541
541
        client = make_node_client(node)
542
542
        response = call_signal(client, status='OK', script_result='0')
543
543
        self.assertEqual(httplib.OK, response.status_code)
547
547
            MockCalledOnceWith(ANY, node))
548
548
 
549
549
    def test_signaling_requires_status_code(self):
550
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
550
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
551
551
        client = make_node_client(node=node)
552
552
        url = reverse('metadata-version', args=['latest'])
553
553
        response = client.post(url, {'op': 'signal'})
558
558
        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
559
559
 
560
560
    def test_signaling_refuses_if_node_in_unexpected_state(self):
561
 
        node = factory.make_node(status=NODE_STATUS.NEW)
 
561
        node = factory.make_Node(status=NODE_STATUS.NEW)
562
562
        client = make_node_client(node=node)
563
563
        response = call_signal(client)
564
564
        self.assertEqual(
569
569
            (response.status_code, response.content))
570
570
 
571
571
    def test_signaling_accepts_WORKING_status(self):
572
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
572
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
573
573
        client = make_node_client(node=node)
574
574
        response = call_signal(client, status='WORKING')
575
575
        self.assertEqual(httplib.OK, response.status_code)
577
577
            NODE_STATUS.COMMISSIONING, reload_object(node).status)
578
578
 
579
579
    def test_signaling_stores_script_result(self):
580
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
580
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
581
581
        client = make_node_client(node=node)
582
582
        script_result = random.randint(0, 10)
583
583
        filename = factory.make_string()
589
589
        self.assertEqual(script_result, result.script_result)
590
590
 
591
591
    def test_signaling_stores_empty_script_result(self):
592
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
592
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
593
593
        client = make_node_client(node=node)
594
594
        response = call_signal(
595
595
            client, script_result=random.randint(0, 10),
599
599
        self.assertEqual('', result.data)
600
600
 
601
601
    def test_signaling_WORKING_keeps_owner(self):
602
 
        user = factory.make_user()
603
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
602
        user = factory.make_User()
 
603
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
604
604
        node.owner = user
605
605
        node.save()
606
606
        client = make_node_client(node=node)
609
609
        self.assertEqual(user, reload_object(node).owner)
610
610
 
611
611
    def test_signaling_commissioning_success_makes_node_Ready(self):
612
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
612
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
613
613
        client = make_node_client(node=node)
614
614
        response = call_signal(client, status='OK')
615
615
        self.assertEqual(httplib.OK, response.status_code)
616
616
        self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
617
617
 
618
618
    def test_signaling_commissioning_success_is_idempotent(self):
619
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
619
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
620
620
        client = make_node_client(node=node)
621
621
        call_signal(client, status='OK')
622
622
        response = call_signal(client, status='OK')
624
624
        self.assertEqual(NODE_STATUS.READY, reload_object(node).status)
625
625
 
626
626
    def test_signaling_commissioning_success_clears_owner(self):
627
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
628
 
        node.owner = factory.make_user()
 
627
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
 
628
        node.owner = factory.make_User()
629
629
        node.save()
630
630
        client = make_node_client(node=node)
631
631
        response = call_signal(client, status='OK')
633
633
        self.assertEqual(None, reload_object(node).owner)
634
634
 
635
635
    def test_signaling_commissioning_failure_makes_node_Failed_Tests(self):
636
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
636
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
637
637
        client = make_node_client(node=node)
638
638
        response = call_signal(client, status='FAILED')
639
639
        self.assertEqual(httplib.OK, response.status_code)
641
641
            NODE_STATUS.FAILED_COMMISSIONING, reload_object(node).status)
642
642
 
643
643
    def test_signaling_commissioning_failure_is_idempotent(self):
644
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
644
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
645
645
        client = make_node_client(node=node)
646
646
        call_signal(client, status='FAILED')
647
647
        response = call_signal(client, status='FAILED')
650
650
            NODE_STATUS.FAILED_COMMISSIONING, reload_object(node).status)
651
651
 
652
652
    def test_signaling_commissioning_failure_sets_node_error(self):
653
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
653
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
654
654
        client = make_node_client(node=node)
655
655
        error_text = factory.make_string()
656
656
        response = call_signal(client, status='FAILED', error=error_text)
658
658
        self.assertEqual(error_text, reload_object(node).error)
659
659
 
660
660
    def test_signaling_commissioning_failure_clears_owner(self):
661
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
662
 
        node.owner = factory.make_user()
 
661
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
 
662
        node.owner = factory.make_User()
663
663
        node.save()
664
664
        client = make_node_client(node=node)
665
665
        response = call_signal(client, status='FAILED')
667
667
        self.assertEqual(None, reload_object(node).owner)
668
668
 
669
669
    def test_signaling_no_error_clears_existing_error(self):
670
 
        node = factory.make_node(
 
670
        node = factory.make_Node(
671
671
            status=NODE_STATUS.COMMISSIONING, error=factory.make_string())
672
672
        client = make_node_client(node=node)
673
673
        response = call_signal(client)
678
678
        statuses = ['WORKING', 'OK', 'FAILED']
679
679
        filename = factory.make_string()
680
680
        nodes = {
681
 
            status: factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
681
            status: factory.make_Node(status=NODE_STATUS.COMMISSIONING)
682
682
            for status in statuses}
683
683
        for status, node in nodes.items():
684
684
            client = make_node_client(node=node)
694
694
                for status, node in nodes.items()})
695
695
 
696
696
    def test_signal_stores_file_contents(self):
697
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
697
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
698
698
        client = make_node_client(node=node)
699
699
        text = factory.make_string().encode('ascii')
700
700
        script_result = random.randint(0, 10)
706
706
 
707
707
    def test_signal_stores_binary(self):
708
708
        unicode_text = '<\u2621>'
709
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
709
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
710
710
        client = make_node_client(node=node)
711
711
        script_result = random.randint(0, 10)
712
712
        response = call_signal(
721
721
        contents = {
722
722
            factory.make_string(): factory.make_string().encode('ascii')
723
723
            for counter in range(3)}
724
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
724
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
725
725
        client = make_node_client(node=node)
726
726
        script_result = random.randint(0, 10)
727
727
        response = call_signal(
740
740
        # anybody's business, but files up to this size should work.
741
741
        size_limit = 2 ** 20
742
742
        contents = factory.make_string(size_limit, spaces=True)
743
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
743
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
744
744
        client = make_node_client(node=node)
745
745
        script_result = random.randint(0, 10)
746
746
        response = call_signal(
752
752
        self.assertEqual(size_limit, len(stored_data))
753
753
 
754
754
    def test_signal_stores_virtual_tag_on_node_if_virtual(self):
755
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
755
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
756
756
        client = make_node_client(node=node)
757
757
        content = 'virtual'.encode('utf-8')
758
758
        response = call_signal(
764
764
            ["virtual"], [each_tag.name for each_tag in node.tags.all()])
765
765
 
766
766
    def test_signal_removes_virtual_tag_on_node_if_not_virtual(self):
767
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
767
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
768
768
        tag, _ = Tag.objects.get_or_create(name='virtual')
769
769
        node.tags.add(tag)
770
770
        client = make_node_client(node=node)
778
778
            [], [each_tag.name for each_tag in node.tags.all()])
779
779
 
780
780
    def test_signal_leaves_untagged_physical_node_unaltered(self):
781
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
781
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
782
782
        client = make_node_client(node=node)
783
783
        content = 'notvirtual'.encode('utf-8')
784
784
        response = call_signal(
789
789
        self.assertEqual(0, len(node.tags.all()))
790
790
 
791
791
    def test_signal_refuses_bad_power_type(self):
792
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
792
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
793
793
        client = make_node_client(node=node)
794
794
        response = call_signal(client, power_type="foo")
795
795
        self.assertEqual(
797
797
            (response.status_code, response.content))
798
798
 
799
799
    def test_signal_power_type_stores_params(self):
800
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
800
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
801
801
        client = make_node_client(node=node)
802
802
        params = dict(
803
803
            power_address=factory.make_string(),
811
811
        self.assertEqual(params, node.power_parameters)
812
812
 
813
813
    def test_signal_power_type_lower_case_works(self):
814
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
814
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
815
815
        client = make_node_client(node=node)
816
816
        params = dict(
817
817
            power_address=factory.make_string(),
825
825
            params, node.power_parameters)
826
826
 
827
827
    def test_signal_invalid_power_parameters(self):
828
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
828
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
829
829
        client = make_node_client(node=node)
830
830
        response = call_signal(
831
831
            client, power_type="ipmi", power_parameters="badjson")
837
837
class TestByMACMetadataAPI(DjangoTestCase):
838
838
 
839
839
    def test_api_retrieves_node_metadata_by_mac(self):
840
 
        mac = factory.make_mac_address()
 
840
        mac = factory.make_MACAddress()
841
841
        url = reverse(
842
842
            'metadata-meta-data-by-mac',
843
843
            args=['latest', mac.mac_address, 'instance-id'])
847
847
            (response.status_code, response.content))
848
848
 
849
849
    def test_api_retrieves_node_userdata_by_mac(self):
850
 
        mac = factory.make_mac_address()
 
850
        mac = factory.make_MACAddress()
851
851
        user_data = factory.make_string().encode('ascii')
852
852
        NodeUserData.objects.set_user_data(mac.node, user_data)
853
853
        url = reverse(
859
859
 
860
860
    def test_api_normally_disallows_anonymous_node_metadata_access(self):
861
861
        self.patch(settings, 'ALLOW_UNSAFE_METADATA_ACCESS', False)
862
 
        mac = factory.make_mac_address()
 
862
        mac = factory.make_MACAddress()
863
863
        url = reverse(
864
864
            'metadata-meta-data-by-mac',
865
865
            args=['latest', mac.mac_address, 'instance-id'])
870
870
class TestNetbootOperationAPI(DjangoTestCase):
871
871
 
872
872
    def test_netboot_off(self):
873
 
        node = factory.make_node(netboot=True)
 
873
        node = factory.make_Node(netboot=True)
874
874
        client = make_node_client(node=node)
875
875
        url = reverse('metadata-version', args=['latest'])
876
876
        response = client.post(url, {'op': 'netboot_off'})
878
878
        self.assertFalse(node.netboot, response)
879
879
 
880
880
    def test_netboot_on(self):
881
 
        node = factory.make_node(netboot=False)
 
881
        node = factory.make_Node(netboot=False)
882
882
        client = make_node_client(node=node)
883
883
        url = reverse('metadata-version', args=['latest'])
884
884
        response = client.post(url, {'op': 'netboot_on'})
889
889
class TestAnonymousAPI(DjangoTestCase):
890
890
 
891
891
    def test_anonymous_netboot_off(self):
892
 
        node = factory.make_node(netboot=True)
 
892
        node = factory.make_Node(netboot=True)
893
893
        anon_netboot_off_url = reverse(
894
894
            'metadata-node-by-id', args=['latest', node.system_id])
895
895
        response = self.client.post(
922
922
        ng_url = 'http://%s' % factory.make_name('host')
923
923
        network = IPNetwork("10.1.1/24")
924
924
        ip = factory.pick_ip_in_network(network)
925
 
        factory.make_node_group(
 
925
        factory.make_NodeGroup(
926
926
            maas_url=ng_url, network=network,
927
927
            management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
928
928
        anon_enlist_preseed_url = reverse(
934
934
 
935
935
    def test_anonymous_get_preseed(self):
936
936
        # The preseed for a node can be obtained anonymously.
937
 
        node = factory.make_node()
 
937
        node = factory.make_Node()
938
938
        anon_node_url = reverse(
939
939
            'metadata-node-by-id',
940
940
            args=['latest', node.system_id])
1014
1014
        self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
1015
1015
        network = IPNetwork("10.1.1/24")
1016
1016
        ip = factory.pick_ip_in_network(network)
1017
 
        factory.make_node_group(
 
1017
        factory.make_NodeGroup(
1018
1018
            maas_url=nodegroup_url, network=network,
1019
1019
            management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
1020
1020
        url = reverse('enlist-metadata-user-data', args=['latest'])