~landscape/landscape-client/staging

« back to all changes in this revision

Viewing changes to landscape/monitor/tests/test_rebootrequired.py

  • Committer: Simon Poirier
  • Date: 2017-08-17 23:23:07 UTC
  • mfrom: (0.1.996)
  • Revision ID: simon.poirier@canonical.com-20170817232307-6je8sd48dh7731s2
Merged from master r996

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
import mock
2
 
 
3
 
from landscape.monitor.rebootrequired import RebootRequired
4
 
from landscape.tests.helpers import (
5
 
    LandscapeTest, MonitorHelper, LogKeeperHelper)
6
 
 
7
 
 
8
 
class RebootRequiredTest(LandscapeTest):
9
 
 
10
 
    helpers = [MonitorHelper, LogKeeperHelper]
11
 
 
12
 
    def setUp(self):
13
 
        super(RebootRequiredTest, self).setUp()
14
 
        self.reboot_required_filename = self.makeFile()
15
 
        self.plugin = RebootRequired(self.reboot_required_filename)
16
 
        self.monitor.add(self.plugin)
17
 
        self.mstore.set_accepted_types(["reboot-required-info"])
18
 
 
19
 
    def test_wb_get_flag(self):
20
 
        """
21
 
        L{RebootRequired._get_flag} returns C{True} if the reboot-required
22
 
        flag file is present, C{False} otherwise.
23
 
        """
24
 
        self.assertFalse(self.plugin._get_flag())
25
 
        self.makeFile(path=self.reboot_required_filename, content="")
26
 
        self.assertTrue(self.plugin._get_flag())
27
 
 
28
 
    def test_wb_get_packages(self):
29
 
        """
30
 
        L{RebootRequired._get_packages} returns the packages listed in the
31
 
        reboot-required packages file if present, or an empty list otherwise.
32
 
        """
33
 
        self.assertEqual([], self.plugin._get_packages())
34
 
        self.makeFile(path=self.reboot_required_filename + ".pkgs",
35
 
                      content="foo\nbar\n")
36
 
        self.assertEqual(["bar", "foo"], self.plugin._get_packages())
37
 
 
38
 
    def test_wb_get_packages_with_duplicates(self):
39
 
        """
40
 
        The list of packages returned by L{RebootRequired._get_packages} does
41
 
        not contain duplicate values.
42
 
        """
43
 
        self.assertEqual([], self.plugin._get_packages())
44
 
        self.makeFile(path=self.reboot_required_filename + ".pkgs",
45
 
                      content="foo\nfoo\n")
46
 
        self.assertEqual(["foo"], self.plugin._get_packages())
47
 
 
48
 
    def test_wb_get_packages_with_blank_lines(self):
49
 
        """
50
 
        Blank lines are ignored by L{RebootRequired._get_packages}.
51
 
        """
52
 
        self.assertEqual([], self.plugin._get_packages())
53
 
        self.makeFile(path=self.reboot_required_filename + ".pkgs",
54
 
                      content="bar\n\nfoo\n")
55
 
        self.assertEqual(["bar", "foo"], self.plugin._get_packages())
56
 
 
57
 
    def test_wb_create_message(self):
58
 
        """
59
 
        A message should be created if and only if the reboot-required status
60
 
        of the system has changed.
61
 
        """
62
 
        self.assertEqual({"flag": False, "packages": []},
63
 
                         self.plugin._create_message())
64
 
        self.makeFile(path=self.reboot_required_filename, content="")
65
 
        self.assertEqual({"flag": True},
66
 
                         self.plugin._create_message())
67
 
        self.makeFile(path=self.reboot_required_filename + ".pkgs",
68
 
                      content="foo\n")
69
 
        self.assertEqual({"packages": [u"foo"]},
70
 
                         self.plugin._create_message())
71
 
 
72
 
    def test_send_message(self):
73
 
        """
74
 
        A new C{"reboot-required-info"} message should be enqueued if and only
75
 
        if the reboot-required status of the system has changed.
76
 
        """
77
 
        self.makeFile(path=self.reboot_required_filename + ".pkgs",
78
 
                      content="foo\n")
79
 
        self.makeFile(path=self.reboot_required_filename, content="")
80
 
        self.plugin.send_message()
81
 
        self.assertIn("Queueing message with updated reboot-required status.",
82
 
                      self.logfile.getvalue())
83
 
        self.assertMessages(self.mstore.get_pending_messages(),
84
 
                            [{"type": "reboot-required-info",
85
 
                              "flag": True,
86
 
                              "packages": [u"foo"]}])
87
 
        self.mstore.delete_all_messages()
88
 
        self.plugin.send_message()
89
 
        self.assertMessages(self.mstore.get_pending_messages(), [])
90
 
 
91
 
    def test_run_interval(self):
92
 
        """
93
 
        The L{RebootRequired} plugin will be scheduled to run every 15 minutes.
94
 
        """
95
 
        self.assertEqual(900, self.plugin.run_interval)
96
 
 
97
 
    def test_run_immediately(self):
98
 
        """
99
 
        The L{RebootRequired} plugin will be run immediately at startup.
100
 
        """
101
 
        self.assertTrue(True, self.plugin.run_immediately)
102
 
 
103
 
    def test_run(self):
104
 
        """
105
 
        If the server can accept them, the plugin should send
106
 
        C{reboot-required} messages.
107
 
        """
108
 
        with mock.patch.object(self.remote, "send_message"):
109
 
            self.plugin.run()
110
 
            self.remote.send_message.assert_called_once_with(
111
 
                mock.ANY, mock.ANY, urgent=True)
112
 
        self.mstore.set_accepted_types([])
113
 
        self.plugin.run()
114
 
 
115
 
    def test_resynchronize(self):
116
 
        """
117
 
        The "resynchronize" reactor message cause the plugin to send fresh
118
 
        data.
119
 
        """
120
 
        self.plugin.run()
121
 
        self.reactor.fire("resynchronize", scopes=["package"])
122
 
        self.plugin.run()
123
 
        messages = self.mstore.get_pending_messages()
124
 
        self.assertEqual(len(messages), 2)