← Back to branch summary

~hopem/charms/trusty/swift-proxy/lp1518975

« back to all changes in this revision

Viewing changes to unit_tests/test_actions.py

  • Committer: Christopher Glass
  • Date: 2015-09-11 07:30:34 UTC
  • mfrom: (107.2.8 add-pause-resume-actions)
  • Revision ID: christopher.glass@canonical.com-20150911073034-hkn326duunz2y63q
Merge lp:~adam-collard/charms/trusty/swift-proxy/add-pause-resume-actions [a=adam-collard] [r=tribaal, tealeg]

Add actions for pausing and resuming services on swift-storage units.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unit_tests/test_actions.py
 
1
import argparse
 
2
import tempfile
 
3
import unittest
 
4
 
 
5
import mock
 
6
import yaml
 
7
 
 
8
import actions.actions
 
9
 
 
10
 
 
11
class CharmTestCase(unittest.TestCase):
 
12
 
 
13
    def setUp(self, obj, patches):
 
14
        super(CharmTestCase, self).setUp()
 
15
        self.patches = patches
 
16
        self.obj = obj
 
17
        self.patch_all()
 
18
 
 
19
    def patch(self, method):
 
20
        _m = mock.patch.object(self.obj, method)
 
21
        mocked = _m.start()
 
22
        self.addCleanup(_m.stop)
 
23
        return mocked
 
24
 
 
25
    def patch_all(self):
 
26
        for method in self.patches:
 
27
            setattr(self, method, self.patch(method))
 
28
 
 
29
 
 
30
class PauseTestCase(CharmTestCase):
 
31
 
 
32
    def setUp(self):
 
33
        super(PauseTestCase, self).setUp(
 
34
            actions.actions, ["service_pause", "status_set"])
 
35
 
 
36
        class FakeArgs(object):
 
37
            services = ['swift-proxy', 'haproxy', 'memcached', 'apache2']
 
38
        self.args = FakeArgs()
 
39
 
 
40
    def test_pauses_services(self):
 
41
        """Pause action pauses all of the Swift services."""
 
42
        pause_calls = []
 
43
 
 
44
        def fake_service_pause(svc):
 
45
            pause_calls.append(svc)
 
46
            return True
 
47
 
 
48
        self.service_pause.side_effect = fake_service_pause
 
49
 
 
50
        actions.actions.pause(self.args)
 
51
        self.assertEqual(
 
52
            pause_calls, ['swift-proxy', 'haproxy', 'memcached', 'apache2'])
 
53
 
 
54
    def test_bails_out_early_on_error(self):
 
55
        """Pause action fails early if there are errors stopping a service."""
 
56
        pause_calls = []
 
57
 
 
58
        def maybe_kill(svc):
 
59
            if svc == "haproxy":
 
60
                return False
 
61
            else:
 
62
                pause_calls.append(svc)
 
63
                return True
 
64
 
 
65
        self.service_pause.side_effect = maybe_kill
 
66
        self.assertRaisesRegexp(
 
67
            Exception, "haproxy didn't stop cleanly.",
 
68
            actions.actions.pause, self.args)
 
69
        self.assertEqual(pause_calls, ["swift-proxy"])
 
70
 
 
71
    def test_status_mode(self):
 
72
        """Pause action sets the status to maintenance."""
 
73
        status_calls = []
 
74
        self.status_set.side_effect = lambda state, msg: status_calls.append(
 
75
            state)
 
76
 
 
77
        actions.actions.pause(self.args)
 
78
        self.assertEqual(status_calls, ["maintenance"])
 
79
 
 
80
    def test_status_message(self):
 
81
        """Pause action sets a status message reflecting that it's paused."""
 
82
        status_calls = []
 
83
        self.status_set.side_effect = lambda state, msg: status_calls.append(
 
84
            msg)
 
85
 
 
86
        actions.actions.pause(self.args)
 
87
        self.assertEqual(
 
88
            status_calls, ["Paused. "
 
89
                           "Use 'resume' action to resume normal service."])
 
90
 
 
91
 
 
92
class ResumeTestCase(CharmTestCase):
 
93
 
 
94
    def setUp(self):
 
95
        super(ResumeTestCase, self).setUp(
 
96
            actions.actions, ["service_resume", "status_set"])
 
97
 
 
98
        class FakeArgs(object):
 
99
            services = ['swift-proxy', 'haproxy', 'memcached', 'apache2']
 
100
        self.args = FakeArgs()
 
101
 
 
102
    def test_resumes_services(self):
 
103
        """Resume action resumes all of the Swift services."""
 
104
        resume_calls = []
 
105
 
 
106
        def fake_service_resume(svc):
 
107
            resume_calls.append(svc)
 
108
            return True
 
109
 
 
110
        self.service_resume.side_effect = fake_service_resume
 
111
        actions.actions.resume(self.args)
 
112
        self.assertEqual(
 
113
            resume_calls, ['swift-proxy', 'haproxy', 'memcached', 'apache2'])
 
114
 
 
115
    def test_bails_out_early_on_error(self):
 
116
        """Resume action fails early if there are errors starting a service."""
 
117
        resume_calls = []
 
118
 
 
119
        def maybe_kill(svc):
 
120
            if svc == "haproxy":
 
121
                return False
 
122
            else:
 
123
                resume_calls.append(svc)
 
124
                return True
 
125
 
 
126
        self.service_resume.side_effect = maybe_kill
 
127
        self.assertRaisesRegexp(
 
128
            Exception, "haproxy didn't start cleanly.",
 
129
            actions.actions.resume, self.args)
 
130
        self.assertEqual(resume_calls, ['swift-proxy'])
 
131
 
 
132
    def test_status_mode(self):
 
133
        """Resume action sets the status to maintenance."""
 
134
        status_calls = []
 
135
        self.status_set.side_effect = lambda state, msg: status_calls.append(
 
136
            state)
 
137
 
 
138
        actions.actions.resume(self.args)
 
139
        self.assertEqual(status_calls, ["active"])
 
140
 
 
141
    def test_status_message(self):
 
142
        """Resume action sets an empty status message."""
 
143
        status_calls = []
 
144
        self.status_set.side_effect = lambda state, msg: status_calls.append(
 
145
            msg)
 
146
 
 
147
        actions.actions.resume(self.args)
 
148
        self.assertEqual(status_calls, [""])
 
149
 
 
150
 
 
151
class GetActionParserTestCase(unittest.TestCase):
 
152
 
 
153
    def test_definition_from_yaml(self):
 
154
        """ArgumentParser is seeded from actions.yaml."""
 
155
        actions_yaml = tempfile.NamedTemporaryFile(
 
156
            prefix="GetActionParserTestCase", suffix="yaml")
 
157
        actions_yaml.write(yaml.dump({"foo": {"description": "Foo is bar"}}))
 
158
        actions_yaml.seek(0)
 
159
        parser = actions.actions.get_action_parser(actions_yaml.name, "foo",
 
160
                                                   get_services=lambda: [])
 
161
        self.assertEqual(parser.description, 'Foo is bar')
 
162
 
 
163
 
 
164
class MainTestCase(CharmTestCase):
 
165
 
 
166
    def setUp(self):
 
167
        super(MainTestCase, self).setUp(
 
168
            actions.actions, ["_get_action_name",
 
169
                              "get_action_parser",
 
170
                              "action_fail"])
 
171
 
 
172
    def test_invokes_pause(self):
 
173
        dummy_calls = []
 
174
 
 
175
        def dummy_action(args):
 
176
            dummy_calls.append(True)
 
177
 
 
178
        self._get_action_name.side_effect = lambda: "foo"
 
179
        self.get_action_parser = lambda: argparse.ArgumentParser()
 
180
        with mock.patch.dict(actions.actions.ACTIONS, {"foo": dummy_action}):
 
181
            actions.actions.main([])
 
182
        self.assertEqual(dummy_calls, [True])
 
183
 
 
184
    def test_unknown_action(self):
 
185
        """Unknown actions aren't a traceback."""
 
186
        self._get_action_name.side_effect = lambda: "foo"
 
187
        self.get_action_parser = lambda: argparse.ArgumentParser()
 
188
        exit_string = actions.actions.main([])
 
189
        self.assertEqual("Action foo undefined", exit_string)
 
190
 
 
191
    def test_failing_action(self):
 
192
        """Actions which traceback trigger action_fail() calls."""
 
193
        dummy_calls = []
 
194
 
 
195
        self.action_fail.side_effect = dummy_calls.append
 
196
        self._get_action_name.side_effect = lambda: "foo"
 
197
 
 
198
        def dummy_action(args):
 
199
            raise ValueError("uh oh")
 
200
 
 
201
        self.get_action_parser = lambda: argparse.ArgumentParser()
 
202
        with mock.patch.dict(actions.actions.ACTIONS, {"foo": dummy_action}):
 
203
            actions.actions.main([])
 
204
        self.assertEqual(dummy_calls, ["uh oh"])