← Back to branch summary

~lutostag/ubuntu/trusty/maas/1.5.4+keystone

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2013-03-04 11:49:44 UTC
  • mto: This revision was merged to the branch mainline in revision 25.
  • Revision ID: package-import@ubuntu.com-20130304114944-azcvu9anlf8mizpa
Tags: upstream-1.3+bzr1452+dfsg
Import upstream version 1.3+bzr1452+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/tests/test_node.py
15
15
from datetime import timedelta
16
16
import random
17
17
 
18
 
from django.conf import settings
19
18
from django.core.exceptions import (
20
19
    PermissionDenied,
21
20
    ValidationError,
36
35
    MACAddress,
37
36
    Node,
38
37
    node as node_module,
 
38
    Tag,
39
39
    )
40
40
from maasserver.models.node import (
41
41
    generate_hostname,
50
50
    map_enum,
51
51
    )
52
52
from maastesting.testcase import TestCase as DjangoLessTestCase
 
53
from metadataserver import commissioning
53
54
from metadataserver.models import (
54
55
    NodeCommissionResult,
55
56
    NodeUserData,
60
61
    AllMatch,
61
62
    Contains,
62
63
    Equals,
63
 
    FileContains,
64
64
    MatchesAll,
65
65
    MatchesListwise,
66
66
    Not,
317
317
        successful_types = [node_power_types[node] for node in started_nodes]
318
318
        self.assertItemsEqual(configless_power_types, successful_types)
319
319
 
 
320
    def test_get_effective_kernel_options_with_nothing_set(self):
 
321
        node = factory.make_node()
 
322
        self.assertEqual((None, None), node.get_effective_kernel_options())
 
323
 
 
324
    def test_get_effective_kernel_options_sees_global_config(self):
 
325
        node = factory.make_node()
 
326
        kernel_opts = factory.getRandomString()
 
327
        Config.objects.set_config('kernel_opts', kernel_opts)
 
328
        self.assertEqual(
 
329
            (None, kernel_opts), node.get_effective_kernel_options())
 
330
 
 
331
    def test_get_effective_kernel_options_not_confused_by_empty_tag(self):
 
332
        node = factory.make_node()
 
333
        tag = factory.make_tag()
 
334
        node.tags.add(tag)
 
335
        kernel_opts = factory.getRandomString()
 
336
        Config.objects.set_config('kernel_opts', kernel_opts)
 
337
        self.assertEqual(
 
338
            (None, kernel_opts), node.get_effective_kernel_options())
 
339
 
 
340
    def test_get_effective_kernel_options_ignores_unassociated_tag_value(self):
 
341
        node = factory.make_node()
 
342
        factory.make_tag(kernel_opts=factory.getRandomString())
 
343
        self.assertEqual((None, None), node.get_effective_kernel_options())
 
344
 
 
345
    def test_get_effective_kernel_options_uses_tag_value(self):
 
346
        node = factory.make_node()
 
347
        tag = factory.make_tag(kernel_opts=factory.getRandomString())
 
348
        node.tags.add(tag)
 
349
        self.assertEqual(
 
350
            (tag, tag.kernel_opts), node.get_effective_kernel_options())
 
351
 
 
352
    def test_get_effective_kernel_options_tag_overrides_global(self):
 
353
        node = factory.make_node()
 
354
        global_opts = factory.getRandomString()
 
355
        Config.objects.set_config('kernel_opts', global_opts)
 
356
        tag = factory.make_tag(kernel_opts=factory.getRandomString())
 
357
        node.tags.add(tag)
 
358
        self.assertEqual(
 
359
            (tag, tag.kernel_opts), node.get_effective_kernel_options())
 
360
 
 
361
    def test_get_effective_kernel_options_uses_first_real_tag_value(self):
 
362
        node = factory.make_node()
 
363
        # Intentionally create them in reverse order, so the default 'db' order
 
364
        # doesn't work, and we have asserted that we sort them.
 
365
        tag3 = factory.make_tag(factory.make_name('tag-03-'),
 
366
                                kernel_opts=factory.getRandomString())
 
367
        tag2 = factory.make_tag(factory.make_name('tag-02-'),
 
368
                                kernel_opts=factory.getRandomString())
 
369
        tag1 = factory.make_tag(factory.make_name('tag-01-'), kernel_opts=None)
 
370
        self.assertTrue(tag1.name < tag2.name)
 
371
        self.assertTrue(tag2.name < tag3.name)
 
372
        node.tags.add(tag1, tag2, tag3)
 
373
        self.assertEqual(
 
374
            (tag2, tag2.kernel_opts), node.get_effective_kernel_options())
 
375
 
320
376
    def test_acquire(self):
321
377
        node = factory.make_node(status=NODE_STATUS.READY)
322
378
        user = factory.make_user()
428
484
 
429
485
    def test_start_commissioning_sets_user_data(self):
430
486
        node = factory.make_node(status=NODE_STATUS.DECLARED)
 
487
        user_data = factory.getRandomString().encode('ascii')
 
488
        self.patch(
 
489
            commissioning.user_data, 'generate_user_data'
 
490
            ).return_value = user_data
431
491
        node.start_commissioning(factory.make_admin())
432
 
        path = settings.COMMISSIONING_SCRIPT
433
 
        self.assertThat(
434
 
            path, FileContains(NodeUserData.objects.get_user_data(node)))
435
 
 
436
 
    def test_missing_commissioning_script(self):
437
 
        self.patch(
438
 
            settings, 'COMMISSIONING_SCRIPT',
439
 
            '/etc/' + factory.getRandomString(10))
440
 
        node = factory.make_node(status=NODE_STATUS.DECLARED)
441
 
        self.assertRaises(
442
 
            ValidationError,
443
 
            node.start_commissioning, factory.make_admin())
 
492
        self.assertEqual(user_data, NodeUserData.objects.get_user_data(node))
 
493
        commissioning.user_data.generate_user_data.assert_called_with(
 
494
            nodegroup=node.nodegroup)
444
495
 
445
496
    def test_start_commissioning_clears_node_commissioning_results(self):
446
497
        node = factory.make_node(status=NODE_STATUS.DECLARED)
447
498
        NodeCommissionResult.objects.store_data(
448
 
            node, factory.getRandomString(), factory.getRandomString())
 
499
            node, factory.getRandomString(),
 
500
            random.randint(0, 10),
 
501
            factory.getRandomString())
449
502
        node.start_commissioning(factory.make_admin())
450
503
        self.assertItemsEqual([], node.nodecommissionresult_set.all())
451
504
 
453
506
        node = factory.make_node()
454
507
        filename = factory.getRandomString()
455
508
        text = factory.getRandomString()
456
 
        NodeCommissionResult.objects.store_data(node, filename, text)
 
509
        script_result = random.randint(0, 10)
 
510
        NodeCommissionResult.objects.store_data(
 
511
            node, filename, script_result, text)
457
512
        other_node = factory.make_node(status=NODE_STATUS.DECLARED)
458
513
        other_node.start_commissioning(factory.make_admin())
459
514
        self.assertEqual(
610
665
        expected_hostname = '%s.%s' % (hostname_without_domain, domain)
611
666
        self.assertEqual(expected_hostname, node.fqdn)
612
667
 
 
668
    def test_should_use_default_installer_by_default(self):
 
669
        node = factory.make_node()
 
670
        self.assertTrue(node.should_use_default_installer())
 
671
 
 
672
    def test_should_use_traditional_installer_not_by_default(self):
 
673
        node = factory.make_node()
 
674
        self.assertFalse(node.should_use_traditional_installer())
 
675
 
 
676
    def test_should_use_default_installer_not_when_tag_applies(self):
 
677
        node = factory.make_node()
 
678
        tag = factory.make_tag(name="use-traditional-installer")
 
679
        tag.save()
 
680
        node.tags.add(tag)
 
681
        self.assertFalse(node.should_use_default_installer())
 
682
 
 
683
    def test_should_use_traditional_installer_when_tag_applies(self):
 
684
        node = factory.make_node()
 
685
        tag = factory.make_tag(name="use-traditional-installer")
 
686
        tag.save()
 
687
        node.tags.add(tag)
 
688
        self.assertTrue(node.should_use_traditional_installer())
 
689
 
 
690
    def test_use_xxx_installer(self):
 
691
        # use_default_installer() and use_traditional_installer() can be used
 
692
        # to affect what the should_use_xxx_installer() methods return.
 
693
        node = factory.make_node()
 
694
        node.use_traditional_installer()
 
695
        self.assertFalse(node.should_use_default_installer())
 
696
        self.assertTrue(node.should_use_traditional_installer())
 
697
        node.use_default_installer()
 
698
        self.assertTrue(node.should_use_default_installer())
 
699
        self.assertFalse(node.should_use_traditional_installer())
 
700
 
 
701
    def test_use_default_installer_dissociates_tag_from_node(self):
 
702
        # use_default_installer removes any association with the
 
703
        # use-traditional-installer tag. The tag is created even if it did not
 
704
        # previously exist. If it does already exist, it is not deleted.
 
705
        find_tag = lambda: list(
 
706
            Tag.objects.filter(name="use-traditional-installer"))
 
707
        node = factory.make_node()
 
708
        node.use_default_installer()
 
709
        self.assertNotEqual([], find_tag())
 
710
        node.use_traditional_installer()
 
711
        node.use_default_installer()
 
712
        self.assertNotEqual([], find_tag())
 
713
 
 
714
    def test_use_traditional_installer_associates_tag_with_node(self):
 
715
        # use_traditional_installer() creates the use-traditional-installer
 
716
        # tag when it is first needed, and associates it with the node.
 
717
        find_tag = lambda: list(
 
718
            Tag.objects.filter(name="use-traditional-installer"))
 
719
        self.assertEqual([], find_tag())
 
720
        node = factory.make_node()
 
721
        node.use_traditional_installer()
 
722
        self.assertNotEqual([], find_tag())
 
723
 
 
724
    def test_use_default_installer_complains_when_tag_has_expression(self):
 
725
        # use_default_installer() complains when the use-traditional-installer
 
726
        # tag exists and is defined with an expression.
 
727
        node = factory.make_node()
 
728
        factory.make_tag(
 
729
            name="use-traditional-installer",
 
730
            definition="//something")
 
731
        error = self.assertRaises(
 
732
            RuntimeError, node.use_default_installer)
 
733
        self.assertIn(
 
734
            "The use-traditional-installer tag is defined with an expression",
 
735
            unicode(error))
 
736
 
 
737
    def test_use_traditional_installer_complains_when_tag_has_expression(self):
 
738
        # use_traditional_installer() complains when the
 
739
        # use-traditional-installer tag exists and is defined with an
 
740
        # expression.
 
741
        node = factory.make_node()
 
742
        factory.make_tag(
 
743
            name="use-traditional-installer",
 
744
            definition="//something")
 
745
        error = self.assertRaises(
 
746
            RuntimeError, node.use_traditional_installer)
 
747
        self.assertIn(
 
748
            "The use-traditional-installer tag is defined with an expression",
 
749
            unicode(error))
 
750
 
613
751
 
614
752
class NodeTransitionsTests(TestCase):
615
753
    """Test the structure of NODE_TRANSITIONS."""