← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ironic/vivid-updates

« back to all changes in this revision

Viewing changes to ironic/tests/conductor/test_conductor_utils.py

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2015-01-05 12:21:37 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20150105122137-171bqrdpcxqipunk
Tags: 2015.1~b1-0ubuntu1
* New upstream beta release:
  - d/control: Align version requirements with upstream release.
* d/watch: Update uversionmangle to deal with kilo beta versioning
  changes.
* d/control: Bumped Standards-Version to 3.9.6, no changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ironic/tests/conductor/test_conductor_utils.py
18
18
from ironic.common import utils as cmn_utils
19
19
from ironic.conductor import task_manager
20
20
from ironic.conductor import utils as conductor_utils
21
 
from ironic.db import api as dbapi
22
21
from ironic import objects
23
22
from ironic.tests import base as tests_base
24
23
from ironic.tests.conductor import utils as mgr_utils
28
27
 
29
28
 
30
29
class NodeSetBootDeviceTestCase(base.DbTestCase):
31
 
    def setUp(self):
32
 
        super(NodeSetBootDeviceTestCase, self).setUp()
33
 
        self.dbapi = dbapi.get_instance()
34
30
 
35
31
    def test_node_set_boot_device_non_existent_device(self):
36
32
        mgr_utils.mock_the_extension_manager(driver="fake_ipmitool")
69
65
 
70
66
    def setUp(self):
71
67
        super(NodePowerActionTestCase, self).setUp()
72
 
        self.dbapi = dbapi.get_instance()
73
68
        mgr_utils.mock_the_extension_manager()
74
69
        self.driver = driver_factory.get_driver("fake")
75
70
 
81
76
                                          power_state=states.POWER_OFF)
82
77
        task = task_manager.TaskManager(self.context, node.uuid)
83
78
 
84
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
85
 
                as get_power_mock:
 
79
        with mock.patch.object(self.driver.power,
 
80
                               'get_power_state') as get_power_mock:
86
81
            get_power_mock.return_value = states.POWER_OFF
87
82
 
88
83
            conductor_utils.node_power_action(task, states.POWER_ON)
101
96
                                          power_state=states.POWER_ON)
102
97
        task = task_manager.TaskManager(self.context, node.uuid)
103
98
 
104
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
105
 
                as get_power_mock:
 
99
        with mock.patch.object(self.driver.power,
 
100
                               'get_power_state') as get_power_mock:
106
101
            get_power_mock.return_value = states.POWER_ON
107
102
 
108
103
            conductor_utils.node_power_action(task, states.POWER_OFF)
131
126
            self.assertIsNone(node['last_error'])
132
127
 
133
128
    def test_node_power_action_invalid_state(self):
134
 
        """Test if an exception is thrown when changing to an invalid
135
 
        power state.
136
 
        """
 
129
        """Test for exception when changing to an invalid power state."""
137
130
        node = obj_utils.create_test_node(self.context,
138
131
                                          uuid=cmn_utils.generate_uuid(),
139
132
                                          driver='fake',
140
133
                                          power_state=states.POWER_ON)
141
134
        task = task_manager.TaskManager(self.context, node.uuid)
142
135
 
143
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
144
 
                as get_power_mock:
 
136
        with mock.patch.object(self.driver.power,
 
137
                               'get_power_state') as get_power_mock:
145
138
            get_power_mock.return_value = states.POWER_ON
146
139
 
147
140
            self.assertRaises(exception.InvalidParameterValue,
163
156
            self.assertIsNone(node['last_error'])
164
157
 
165
158
    def test_node_power_action_already_being_processed(self):
166
 
        """The target_power_state is expected to be None so it isn't
 
159
        """Test node power action after aborted power action.
 
160
 
 
161
        The target_power_state is expected to be None so it isn't
167
162
        checked in the code. This is what happens if it is not None.
168
163
        (Eg, if a conductor had died during a previous power-off
169
164
        attempt and left the target_power_state set to states.POWER_OFF,
184
179
        self.assertIsNone(node['last_error'])
185
180
 
186
181
    def test_node_power_action_in_same_state(self):
187
 
        """Test that we don't try to set the power state if the requested
 
182
        """Test setting node state to its present state.
 
183
 
 
184
        Test that we don't try to set the power state if the requested
188
185
        state is the same as the current state.
189
186
        """
190
187
        node = obj_utils.create_test_node(self.context,
194
191
                                          power_state=states.POWER_ON)
195
192
        task = task_manager.TaskManager(self.context, node.uuid)
196
193
 
197
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
198
 
                as get_power_mock:
 
194
        with mock.patch.object(self.driver.power,
 
195
                               'get_power_state') as get_power_mock:
199
196
            get_power_mock.return_value = states.POWER_ON
200
197
 
201
 
            with mock.patch.object(self.driver.power, 'set_power_state') \
202
 
                    as set_power_mock:
 
198
            with mock.patch.object(self.driver.power,
 
199
                                   'set_power_state') as set_power_mock:
203
200
                conductor_utils.node_power_action(task, states.POWER_ON)
204
201
 
205
202
                node.refresh()
211
208
                self.assertIsNone(node['last_error'])
212
209
 
213
210
    def test_node_power_action_failed_getting_state(self):
214
 
        """Test if an exception is thrown when we can't get the
215
 
        current power state.
216
 
        """
 
211
        """Test for exception when we can't get the current power state."""
217
212
        node = obj_utils.create_test_node(self.context,
218
213
                                          uuid=cmn_utils.generate_uuid(),
219
214
                                          driver='fake',
220
215
                                          power_state=states.POWER_ON)
221
216
        task = task_manager.TaskManager(self.context, node.uuid)
222
217
 
223
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
224
 
                as get_power_state_mock:
225
 
            get_power_state_mock.side_effect = \
226
 
                exception.InvalidParameterValue('failed getting power state')
 
218
        with mock.patch.object(self.driver.power,
 
219
                               'get_power_state') as get_power_state_mock:
 
220
            get_power_state_mock.side_effect = (
 
221
                exception.InvalidParameterValue('failed getting power state'))
227
222
 
228
223
            self.assertRaises(exception.InvalidParameterValue,
229
224
                              conductor_utils.node_power_action,
237
232
            self.assertIsNotNone(node['last_error'])
238
233
 
239
234
    def test_node_power_action_set_power_failure(self):
240
 
        """Test if an exception is thrown when the set_power call
241
 
        fails.
242
 
        """
 
235
        """Test if an exception is thrown when the set_power call fails."""
243
236
        node = obj_utils.create_test_node(self.context,
244
237
                                          uuid=cmn_utils.generate_uuid(),
245
238
                                          driver='fake',
246
239
                                          power_state=states.POWER_OFF)
247
240
        task = task_manager.TaskManager(self.context, node.uuid)
248
241
 
249
 
        with mock.patch.object(self.driver.power, 'get_power_state') \
250
 
                as get_power_mock:
251
 
            with mock.patch.object(self.driver.power, 'set_power_state') \
252
 
                    as set_power_mock:
 
242
        with mock.patch.object(self.driver.power,
 
243
                               'get_power_state') as get_power_mock:
 
244
            with mock.patch.object(self.driver.power,
 
245
                                   'set_power_state') as set_power_mock:
253
246
                get_power_mock.return_value = states.POWER_OFF
254
247
                set_power_mock.side_effect = exception.IronicException()
255
248
 
278
271
        self.task.node = mock.Mock(spec_set=objects.Node)
279
272
        self.node = self.task.node
280
273
 
 
274
        def set_state(state):
 
275
            self.node.provision_state = states.DEPLOYFAIL
 
276
            self.node.target_provision_state = states.NOSTATE
 
277
        process_event_mock = self.task.process_event
 
278
        process_event_mock.side_effect = set_state
 
279
 
281
280
    def test_cleanup_after_timeout(self):
282
281
        conductor_utils.cleanup_after_timeout(self.task)
283
282