← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/maasserver/tests/test_preseed.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/tests/test_preseed.py
109
109
        prefix = factory.make_string()
110
110
        osystem = factory.make_string()
111
111
        release = factory.make_string()
112
 
        node = factory.make_node(hostname=hostname)
 
112
        node = factory.make_Node(hostname=hostname)
113
113
        arch, subarch = node.architecture.split('/')
114
114
        self.assertSequenceEqual(
115
115
            [
141
141
        hostname = factory.make_string()
142
142
        osystem = factory.make_string()
143
143
        release = factory.make_string()
144
 
        node = factory.make_node(hostname=hostname)
 
144
        node = factory.make_Node(hostname=hostname)
145
145
        arch, subarch = node.architecture.split('/')
146
146
        self.assertSequenceEqual(
147
147
            [
160
160
        hostname = factory.make_string()
161
161
        prefix = factory.make_string()
162
162
        release = factory.make_string()
163
 
        node = factory.make_node(hostname=hostname)
 
163
        node = factory.make_Node(hostname=hostname)
164
164
        self.assertSequenceEqual(
165
165
            'generic',
166
166
            list(get_preseed_filenames(
173
173
        hostname = factory.make_string()
174
174
        prefix = factory.make_string()
175
175
        release = factory.make_string()
176
 
        node = factory.make_node(hostname=hostname)
 
176
        node = factory.make_Node(hostname=hostname)
177
177
        self.assertSequenceEqual(
178
178
            prefix,
179
179
            list(get_preseed_filenames(
258
258
    def test_load_preseed_template_returns_PreseedTemplate(self):
259
259
        name = factory.make_string()
260
260
        self.create_template(self.location, name)
261
 
        node = factory.make_node()
 
261
        node = factory.make_Node()
262
262
        template = load_preseed_template(node, name)
263
263
        self.assertIsInstance(template, PreseedTemplate)
264
264
 
265
265
    def test_load_preseed_template_raises_if_no_template(self):
266
 
        node = factory.make_node()
 
266
        node = factory.make_Node()
267
267
        unknown_template_name = factory.make_string()
268
268
        self.assertRaises(
269
269
            TemplateNotFoundError, load_preseed_template, node,
273
273
        # The template lookup method ends up picking up a template named
274
274
        # 'generic' if no more specific template exist.
275
275
        content = self.create_template(self.location, GENERIC_FILENAME)
276
 
        node = factory.make_node(hostname=factory.make_string())
 
276
        node = factory.make_Node(hostname=factory.make_string())
277
277
        template = load_preseed_template(node, factory.make_string())
278
278
        self.assertEqual(content, template.substitute())
279
279
 
286
286
        # Create the 'prefix' template.  This is the one which will be
287
287
        # picked up.
288
288
        content = self.create_template(self.location, prefix)
289
 
        node = factory.make_node(hostname=factory.make_string())
 
289
        node = factory.make_Node(hostname=factory.make_string())
290
290
        template = load_preseed_template(node, prefix)
291
291
        self.assertEqual(content, template.substitute())
292
292
 
300
300
        # due to the presence of a more specific template.
301
301
        self.create_template(self.location, GENERIC_FILENAME)
302
302
        self.create_template(self.location, prefix)
303
 
        node = factory.make_node(hostname=factory.make_string())
 
303
        node = factory.make_Node(hostname=factory.make_string())
304
304
        node_template_name = "%s_%s_%s_%s_%s" % (
305
305
            prefix, osystem, node.architecture.replace('/', '_'),
306
306
            release, node.hostname)
318
318
        self.create_template(self.location, prefix, preseed_content)
319
319
        master_content = self.create_template(
320
320
            self.location, master_template_name)
321
 
        node = factory.make_node()
 
321
        node = factory.make_Node()
322
322
        template = load_preseed_template(node, prefix)
323
323
        self.assertEqual(master_content, template.substitute())
324
324
 
333
333
        # Create preseed template.
334
334
        preseed_content = '{{inherit "%s"}}' % unknown_master_template_name
335
335
        self.create_template(self.location, prefix, preseed_content)
336
 
        node = factory.make_node()
 
336
        node = factory.make_Node()
337
337
        template = load_preseed_template(node, prefix)
338
338
        self.assertRaises(
339
339
            TemplateNotFoundError, template.substitute)
344
344
 
345
345
    def make_bare_nodegroup(self):
346
346
        """Create `NodeGroup` without interfaces."""
347
 
        nodegroup = factory.make_node_group()
 
347
        nodegroup = factory.make_NodeGroup()
348
348
        nodegroup.nodegroupinterface_set.all().delete()
349
349
        return nodegroup
350
350
 
356
356
        Other network settings are derived from the IP address.
357
357
        """
358
358
        network = make_network(ip, subnet_mask)
359
 
        return factory.make_node_group_interface(
 
359
        return factory.make_NodeGroupInterface(
360
360
            nodegroup=nodegroup, management=mgt, network=network, ip=ip,
361
361
            subnet_mask=subnet_mask)
362
362
 
363
363
    def make_lease_for_node(self, node, ip=None):
364
364
        """Create a `MACAddress` and corresponding `DHCPLease` for `node`."""
365
 
        mac = factory.make_mac_address(node=node).mac_address
366
 
        factory.make_dhcp_lease(nodegroup=node.nodegroup, mac=mac, ip=ip)
 
365
        mac = factory.make_MACAddress(node=node).mac_address
 
366
        factory.make_DHCPLease(nodegroup=node.nodegroup, mac=mac, ip=ip)
367
367
 
368
368
    def test_returns_only_interface(self):
369
 
        node = factory.make_node()
370
 
        interface = factory.make_node_group_interface(node.nodegroup)
 
369
        node = factory.make_Node()
 
370
        interface = factory.make_NodeGroupInterface(node.nodegroup)
371
371
 
372
372
        address = pick_cluster_controller_address(node)
373
373
 
380
380
        self.make_nodegroupinterface(nodegroup, '192.168.11.1')
381
381
        self.make_nodegroupinterface(nodegroup, nearest_address)
382
382
        self.make_nodegroupinterface(nodegroup, '192.168.22.1')
383
 
        node = factory.make_node(nodegroup=nodegroup)
 
383
        node = factory.make_Node(nodegroup=nodegroup)
384
384
        self.make_lease_for_node(node, '192.168.33.101')
385
385
        self.make_lease_for_node(node, '10.99.1.105')
386
386
        self.make_lease_for_node(node, '192.168.44.101')
392
392
            nodegroup, '10.100.100.1',
393
393
            mgt=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
394
394
        self.make_nodegroupinterface(nodegroup, '10.100.101.1')
395
 
        node = factory.make_node(nodegroup=nodegroup)
 
395
        node = factory.make_Node(nodegroup=nodegroup)
396
396
        self.make_lease_for_node(node, '10.100.101.99')
397
397
        self.assertEqual('10.100.101.1', pick_cluster_controller_address(node))
398
398
 
399
399
    def test_prefers_managed_interface_over_unmanaged_interface(self):
400
400
        nodegroup = self.make_bare_nodegroup()
401
 
        factory.make_node_group_interface(
 
401
        factory.make_NodeGroupInterface(
402
402
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
403
 
        best_interface = factory.make_node_group_interface(
 
403
        best_interface = factory.make_NodeGroupInterface(
404
404
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
405
 
        factory.make_node_group_interface(
 
405
        factory.make_NodeGroupInterface(
406
406
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
407
407
 
408
408
        address = pick_cluster_controller_address(
409
 
            factory.make_node(nodegroup=nodegroup))
 
409
            factory.make_Node(nodegroup=nodegroup))
410
410
 
411
411
        self.assertIsNotNone(address)
412
412
        self.assertEqual(best_interface.ip, address)
413
413
 
414
414
    def test_prefers_dns_managed_interface_over_unmanaged_interface(self):
415
415
        nodegroup = self.make_bare_nodegroup()
416
 
        factory.make_node_group_interface(
 
416
        factory.make_NodeGroupInterface(
417
417
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
418
 
        best_interface = factory.make_node_group_interface(
 
418
        best_interface = factory.make_NodeGroupInterface(
419
419
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
420
 
        factory.make_node_group_interface(
 
420
        factory.make_NodeGroupInterface(
421
421
            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
422
422
 
423
423
        address = pick_cluster_controller_address(
424
 
            factory.make_node(nodegroup=nodegroup))
 
424
            factory.make_Node(nodegroup=nodegroup))
425
425
 
426
426
        self.assertIsNotNone(address)
427
427
        self.assertEqual(best_interface.ip, address)
428
428
 
429
429
    def test_returns_None_if_no_interfaces(self):
430
 
        nodegroup = factory.make_node_group()
 
430
        nodegroup = factory.make_NodeGroup()
431
431
        nodegroup.nodegroupinterface_set.all().delete()
432
432
        self.assertIsNone(
433
433
            pick_cluster_controller_address(
434
 
                factory.make_node(nodegroup=nodegroup)))
 
434
                factory.make_Node(nodegroup=nodegroup)))
435
435
 
436
436
    def test_makes_consistent_choice(self):
437
437
        # Not a very thorough test, but we want at least a little bit of
438
438
        # predictability.
439
 
        nodegroup = factory.make_node_group(
 
439
        nodegroup = factory.make_NodeGroup(
440
440
            NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
441
441
        for _ in range(5):
442
 
            factory.make_node_group_interface(
 
442
            factory.make_NodeGroupInterface(
443
443
                nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
444
 
        node = factory.make_node(nodegroup=nodegroup)
 
444
        node = factory.make_Node(nodegroup=nodegroup)
445
445
        self.assertEqual(
446
446
            pick_cluster_controller_address(node),
447
447
            pick_cluster_controller_address(node))
452
452
 
453
453
    def test_get_preseed_context_contains_keys(self):
454
454
        release = factory.make_string()
455
 
        nodegroup = factory.make_node_group(maas_url=factory.make_string())
 
455
        nodegroup = factory.make_NodeGroup(maas_url=factory.make_string())
456
456
        context = get_preseed_context(release, nodegroup)
457
457
        self.assertItemsEqual(
458
458
            ['osystem', 'release', 'metadata_enlist_url', 'server_host',
468
468
        ports_archive = factory.make_url(netloc="ports-archive.example.com")
469
469
        Config.objects.set_config('main_archive', main_archive)
470
470
        Config.objects.set_config('ports_archive', ports_archive)
471
 
        nodegroup = factory.make_node_group(maas_url=factory.make_string())
472
 
        context = get_preseed_context(factory.make_node(), nodegroup)
 
471
        nodegroup = factory.make_NodeGroup(maas_url=factory.make_string())
 
472
        context = get_preseed_context(factory.make_Node(), nodegroup)
473
473
        parsed_main_archive = urlparse(main_archive)
474
474
        parsed_ports_archive = urlparse(ports_archive)
475
475
        self.assertEqual(
491
491
    """Tests for `get_node_preseed_context`."""
492
492
 
493
493
    def test_get_node_preseed_context_contains_keys(self):
494
 
        node = factory.make_node(nodegroup=self.rpc_nodegroup)
 
494
        node = factory.make_Node(nodegroup=self.rpc_nodegroup)
495
495
        release = factory.make_string()
496
496
        context = get_node_preseed_context(node, release)
497
497
        self.assertItemsEqual(
502
502
            context)
503
503
 
504
504
    def test_context_contains_third_party_drivers(self):
505
 
        node = factory.make_node(nodegroup=self.rpc_nodegroup)
 
505
        node = factory.make_Node(nodegroup=self.rpc_nodegroup)
506
506
        release = factory.make_string()
507
507
        enable_third_party_drivers = factory.pick_bool()
508
508
        Config.objects.set_config(
539
539
    ]
540
540
 
541
541
    def test_render_preseed(self):
542
 
        node = factory.make_node(nodegroup=self.rpc_nodegroup)
 
542
        node = factory.make_Node(nodegroup=self.rpc_nodegroup)
543
543
        preseed = render_preseed(node, self.preseed, "precise")
544
544
        # The test really is that the preseed is rendered without an
545
545
        # error.
550
550
        self.rpc_nodegroup.maas_url = ng_url
551
551
        self.rpc_nodegroup.save()
552
552
        maas_url = 'http://%s' % factory.make_hostname()
553
 
        node = factory.make_node(
 
553
        node = factory.make_Node(
554
554
            nodegroup=self.rpc_nodegroup, status=NODE_STATUS.COMMISSIONING)
555
555
        self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
556
556
        preseed = render_preseed(node, self.preseed, "precise")
583
583
        ng_url = 'http://%s' % factory.make_hostname()
584
584
        maas_url = 'http://%s' % factory.make_hostname()
585
585
        self.patch(settings, 'DEFAULT_MAAS_URL', maas_url)
586
 
        nodegroup = factory.make_node_group(maas_url=ng_url)
 
586
        nodegroup = factory.make_NodeGroup(maas_url=ng_url)
587
587
        preseed = render_enlistment_preseed(
588
588
            self.preseed, "precise", nodegroup=nodegroup)
589
589
        self.assertThat(
617
617
 
618
618
    def test_render_preseed(self):
619
619
        self.return_windows_specific_preseed_data()
620
 
        node = factory.make_node(
 
620
        node = factory.make_Node(
621
621
            nodegroup=self.rpc_nodegroup, osystem='windows',
622
622
            architecture='amd64/generic', distro_series=self.release)
623
 
        factory.make_boot_image(
 
623
        factory.make_BootImage(
624
624
            osystem='windows', architecture='amd64', subarchitecture='generic',
625
625
            release=self.release, purpose='install', nodegroup=node.nodegroup)
626
626
        preseed = render_preseed(
634
634
    """Tests for `get_curtin_userdata`."""
635
635
 
636
636
    def test_get_curtin_userdata(self):
637
 
        node = factory.make_node(
 
637
        node = factory.make_Node(
638
638
            nodegroup=self.rpc_nodegroup, boot_type=NODE_BOOT.FASTPATH)
639
 
        factory.make_node_group_interface(
 
639
        factory.make_NodeGroupInterface(
640
640
            node.nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
641
641
        arch, subarch = node.architecture.split('/')
642
 
        factory.make_boot_image(
 
642
        factory.make_BootImage(
643
643
            osystem=node.get_osystem(),
644
644
            architecture=arch, subarchitecture=subarch,
645
645
            release=node.get_distro_series(), purpose='xinstall',
660
660
    ]
661
661
 
662
662
    def test_get_curtin_userdata(self):
663
 
        node = factory.make_node(
 
663
        node = factory.make_Node(
664
664
            nodegroup=self.rpc_nodegroup, osystem=self.os_name,
665
665
            boot_type=NODE_BOOT.FASTPATH)
666
 
        factory.make_node_group_interface(
 
666
        factory.make_NodeGroupInterface(
667
667
            node.nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
668
668
        arch, subarch = node.architecture.split('/')
669
 
        factory.make_boot_image(
 
669
        factory.make_BootImage(
670
670
            osystem=node.get_osystem(),
671
671
            architecture=arch, subarchitecture=subarch,
672
672
            release=node.get_distro_series(), purpose='xinstall',
681
681
    """Tests for the curtin-related utilities."""
682
682
 
683
683
    def test_get_curtin_config(self):
684
 
        node = factory.make_node(
 
684
        node = factory.make_Node(
685
685
            nodegroup=self.rpc_nodegroup, boot_type=NODE_BOOT.FASTPATH)
686
686
        config = get_curtin_config(node)
687
687
        self.assertThat(
702
702
        if main_arch is None:
703
703
            main_arch = factory.make_name('arch')
704
704
        arch = '%s/%s' % (main_arch, factory.make_name('subarch'))
705
 
        node = factory.make_node(
 
705
        node = factory.make_Node(
706
706
            nodegroup=self.rpc_nodegroup, architecture=arch,
707
707
            boot_type=NODE_BOOT.FASTPATH)
708
708
        return node
749
749
            self.summarise_url(self.extract_archive_setting(userdata)))
750
750
 
751
751
    def test_get_curtin_context(self):
752
 
        node = factory.make_node(
 
752
        node = factory.make_Node(
753
753
            nodegroup=self.rpc_nodegroup, boot_type=NODE_BOOT.FASTPATH)
754
754
        context = get_curtin_context(node)
755
755
        self.assertItemsEqual(
762
762
        architecture = make_usable_architecture(self)
763
763
        xinstall_path = factory.make_name('xi_path')
764
764
        xinstall_type = factory.make_name('xi_type')
765
 
        node = factory.make_node(
 
765
        node = factory.make_Node(
766
766
            nodegroup=self.rpc_nodegroup, osystem=osystem.name,
767
767
            architecture=architecture, distro_series=series)
768
 
        factory.make_node_group_interface(
 
768
        factory.make_NodeGroupInterface(
769
769
            node.nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
770
770
        arch, subarch = architecture.split('/')
771
 
        boot_image = factory.make_boot_image(
 
771
        boot_image = factory.make_BootImage(
772
772
            osystem=osystem.name, architecture=arch,
773
773
            subarchitecture=subarch, release=series,
774
774
            purpose='xinstall', xinstall_path=xinstall_path,
787
787
        osystem = factory.pick_OS()
788
788
        series = factory.pick_release(osystem)
789
789
        architecture = make_usable_architecture(self)
790
 
        node = factory.make_node(
 
790
        node = factory.make_Node(
791
791
            nodegroup=self.rpc_nodegroup, osystem=osystem.name,
792
792
            architecture=architecture, distro_series=series)
793
793
        # Generate a boot image with a different arch/subarch.
794
 
        factory.make_boot_image(
 
794
        factory.make_BootImage(
795
795
            osystem=osystem.name,
796
796
            architecture=factory.make_name('arch'),
797
797
            subarchitecture=factory.make_name('subarch'), release=series,
817
817
        architecture = make_usable_architecture(self)
818
818
        xinstall_path = factory.make_name('xi_path')
819
819
        xinstall_type = 'tgz'
820
 
        node = factory.make_node(
 
820
        node = factory.make_Node(
821
821
            nodegroup=self.rpc_nodegroup, osystem=osystem.name,
822
822
            architecture=architecture, distro_series=series)
823
 
        factory.make_node_group_interface(
 
823
        factory.make_NodeGroupInterface(
824
824
            node.nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP)
825
825
        arch, subarch = architecture.split('/')
826
 
        boot_image = factory.make_boot_image(
 
826
        boot_image = factory.make_BootImage(
827
827
            osystem=osystem.name, architecture=arch,
828
828
            subarchitecture=subarch, release=series,
829
829
            purpose='xinstall', xinstall_path=xinstall_path,
839
839
            installer_url)
840
840
 
841
841
    def test_get_preseed_type_for_commissioning(self):
842
 
        node = factory.make_node(status=NODE_STATUS.COMMISSIONING)
 
842
        node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
843
843
        self.assertEqual(
844
844
            PRESEED_TYPE.COMMISSIONING, get_preseed_type_for(node))
845
845
 
846
846
    def test_get_preseed_type_for_default(self):
847
 
        node = factory.make_node(boot_type=NODE_BOOT.DEBIAN)
 
847
        node = factory.make_Node(boot_type=NODE_BOOT.DEBIAN)
848
848
        factory.make_boot_images_for_node_with_purposes(node, ['install'])
849
849
        self.assertEqual(
850
850
            PRESEED_TYPE.DEFAULT, get_preseed_type_for(node))
851
851
 
852
852
    def test_get_preseed_type_for_curtin(self):
853
 
        node = factory.make_node(boot_type=NODE_BOOT.FASTPATH)
 
853
        node = factory.make_Node(boot_type=NODE_BOOT.FASTPATH)
854
854
        factory.make_boot_images_for_node_with_purposes(node, ['xinstall'])
855
855
        self.assertEqual(
856
856
            PRESEED_TYPE.CURTIN, get_preseed_type_for(node))
857
857
 
858
858
    def test_get_preseed_type_for_default_when_curtin_not_supported(self):
859
 
        node = factory.make_node(boot_type=NODE_BOOT.FASTPATH)
 
859
        node = factory.make_Node(boot_type=NODE_BOOT.FASTPATH)
860
860
        factory.make_boot_images_for_node_with_purposes(node, ['install'])
861
861
        self.assertEqual(
862
862
            PRESEED_TYPE.DEFAULT, get_preseed_type_for(node))
863
863
 
864
864
    def test_get_preseed_type_for_curtin_when_default_not_supported(self):
865
 
        node = factory.make_node(boot_type=NODE_BOOT.DEBIAN)
 
865
        node = factory.make_Node(boot_type=NODE_BOOT.DEBIAN)
866
866
        factory.make_boot_images_for_node_with_purposes(node, ['xinstall'])
867
867
        self.assertEqual(
868
868
            PRESEED_TYPE.CURTIN, get_preseed_type_for(node))
873
873
 
874
874
    def test_render_preseed_uses_default_archives_intel(self):
875
875
        nodes = [
876
 
            factory.make_node(
 
876
            factory.make_Node(
877
877
                nodegroup=self.rpc_nodegroup,
878
878
                architecture=make_usable_architecture(
879
879
                    self, arch_name="i386", subarch_name="generic")),
880
 
            factory.make_node(
 
880
            factory.make_Node(
881
881
                nodegroup=self.rpc_nodegroup,
882
882
                architecture=make_usable_architecture(
883
883
                    self, arch_name="amd64", subarch_name="generic")),
891
891
            self.assertThat(preseed, ContainsAll(default_snippets))
892
892
 
893
893
    def test_render_preseed_uses_default_archives_arm(self):
894
 
        node = factory.make_node(
 
894
        node = factory.make_Node(
895
895
            nodegroup=self.rpc_nodegroup,
896
896
            architecture=make_usable_architecture(
897
897
                self, arch_name="armhf", subarch_name="generic"))
913
913
        expected_proxy_statement = (
914
914
            "mirror/http/proxy string http://%s:8000" % server_host)
915
915
        preseed = render_preseed(
916
 
            factory.make_node(nodegroup=self.rpc_nodegroup),
 
916
            factory.make_Node(nodegroup=self.rpc_nodegroup),
917
917
            PRESEED_TYPE.DEFAULT, "precise")
918
918
        self.assertIn(expected_proxy_statement, preseed)
919
919
 
924
924
        expected_proxy_statement = (
925
925
            "mirror/http/proxy string %s" % http_proxy)
926
926
        preseed = render_preseed(
927
 
            factory.make_node(nodegroup=self.rpc_nodegroup),
 
927
            factory.make_Node(nodegroup=self.rpc_nodegroup),
928
928
            PRESEED_TYPE.DEFAULT, "precise")
929
929
        self.assertIn(expected_proxy_statement, preseed)
930
930
 
936
936
    """
937
937
 
938
938
    def test_get_preseed_returns_default_preseed(self):
939
 
        node = factory.make_node(
 
939
        node = factory.make_Node(
940
940
            nodegroup=self.rpc_nodegroup, boot_type=NODE_BOOT.DEBIAN)
941
941
        factory.make_boot_images_for_node_with_purposes(node, ['install'])
942
942
        preseed = get_preseed(node)
943
943
        self.assertIn('preseed/late_command', preseed)
944
944
 
945
945
    def test_get_preseed_returns_curtin_preseed(self):
946
 
        node = factory.make_node(
 
946
        node = factory.make_Node(
947
947
            nodegroup=self.rpc_nodegroup, boot_type=NODE_BOOT.FASTPATH)
948
948
        factory.make_boot_images_for_node_with_purposes(node, ['xinstall'])
949
949
        preseed = get_preseed(node)
955
955
        self.assertTrue(preseed.startswith('#cloud-config'))
956
956
 
957
957
    def test_get_preseed_returns_commissioning_preseed(self):
958
 
        node = factory.make_node(
 
958
        node = factory.make_Node(
959
959
            nodegroup=self.rpc_nodegroup, status=NODE_STATUS.COMMISSIONING)
960
960
        preseed = get_preseed(node)
961
961
        self.assertIn('#cloud-config', preseed)
977
977
            compose_enlistment_preseed_url(), StartsWith(url))
978
978
 
979
979
    def test_compose_preseed_url_links_to_preseed_for_node(self):
980
 
        node = factory.make_node(nodegroup=self.rpc_nodegroup)
 
980
        node = factory.make_Node(nodegroup=self.rpc_nodegroup)
981
981
        response = self.client.get(compose_preseed_url(node))
982
982
        self.assertEqual(
983
983
            (httplib.OK, get_preseed(node)),
985
985
 
986
986
    def test_compose_preseed_url_returns_absolute_link(self):
987
987
        self.assertThat(
988
 
            compose_preseed_url(factory.make_node()),
 
988
            compose_preseed_url(factory.make_Node()),
989
989
            StartsWith('http://'))