← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ironic/tests/drivers/amt/test_management.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2015-03-30 11:14:57 UTC
  • mfrom: (1.2.6)
  • Revision ID: package-import@ubuntu.com-20150330111457-kr4ju3guf22m4vbz
Tags: 2015.1~b3-0ubuntu1
https://launchpad.net/bugs/1358820
https://launchpad.net/bugs/1429962
* New upstream release.
  + d/control: 
    - Align with upstream dependencies.
    - Add dh-python to build-dependencies.
    - Add psmisc as a dependency. (LP: #1358820)
  + d/p/fix-requirements.patch: Rediffed.
  + d/ironic-conductor.init.in: Fixed typos in LSB headers,
    thanks to JJ Asghar. (LP: #1429962)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ironic/tests/drivers/amt/test_management.py
 
1
#
 
2
# Licensed under the Apache License, Version 2.0 (the "License"); you may
 
3
# not use this file except in compliance with the License. You may obtain
 
4
# a copy of the License at
 
5
#
 
6
#      http://www.apache.org/licenses/LICENSE-2.0
 
7
#
 
8
# Unless required by applicable law or agreed to in writing, software
 
9
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
10
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
11
# License for the specific language governing permissions and limitations
 
12
# under the License.
 
13
 
 
14
"""
 
15
Test class for AMT ManagementInterface
 
16
"""
 
17
 
 
18
import mock
 
19
from oslo_config import cfg
 
20
 
 
21
from ironic.common import boot_devices
 
22
from ironic.common import exception
 
23
from ironic.conductor import task_manager
 
24
from ironic.drivers.modules.amt import common as amt_common
 
25
from ironic.drivers.modules.amt import management as amt_mgmt
 
26
from ironic.drivers.modules.amt import resource_uris
 
27
from ironic.tests.conductor import utils as mgr_utils
 
28
from ironic.tests.db import base as db_base
 
29
from ironic.tests.db import utils as db_utils
 
30
from ironic.tests.drivers.drac import utils as test_utils
 
31
from ironic.tests.objects import utils as obj_utils
 
32
 
 
33
INFO_DICT = db_utils.get_test_amt_info()
 
34
CONF = cfg.CONF
 
35
 
 
36
 
 
37
@mock.patch.object(amt_common, 'pywsman')
 
38
class AMTManagementInteralMethodsTestCase(db_base.DbTestCase):
 
39
 
 
40
    def setUp(self):
 
41
        super(AMTManagementInteralMethodsTestCase, self).setUp()
 
42
        mgr_utils.mock_the_extension_manager(driver='fake_amt')
 
43
        self.node = obj_utils.create_test_node(self.context,
 
44
                                               driver='fake_amt',
 
45
                                               driver_info=INFO_DICT)
 
46
 
 
47
    def test__set_boot_device_order(self, mock_client_pywsman):
 
48
        namespace = resource_uris.CIM_BootConfigSetting
 
49
        device = boot_devices.PXE
 
50
        result_xml = test_utils.build_soap_xml([{'ReturnValue': '0'}],
 
51
                                                namespace)
 
52
        mock_xml = test_utils.mock_wsman_root(result_xml)
 
53
        mock_pywsman = mock_client_pywsman.Client.return_value
 
54
        mock_pywsman.invoke.return_value = mock_xml
 
55
 
 
56
        amt_mgmt._set_boot_device_order(self.node, device)
 
57
 
 
58
        mock_pywsman.invoke.assert_called_once_with(mock.ANY,
 
59
            namespace, 'ChangeBootOrder')
 
60
 
 
61
    def test__set_boot_device_order_fail(self, mock_client_pywsman):
 
62
        namespace = resource_uris.CIM_BootConfigSetting
 
63
        device = boot_devices.PXE
 
64
        result_xml = test_utils.build_soap_xml([{'ReturnValue': '2'}],
 
65
                                               namespace)
 
66
        mock_xml = test_utils.mock_wsman_root(result_xml)
 
67
        mock_pywsman = mock_client_pywsman.Client.return_value
 
68
        mock_pywsman.invoke.return_value = mock_xml
 
69
 
 
70
        self.assertRaises(exception.AMTFailure,
 
71
                          amt_mgmt._set_boot_device_order, self.node, device)
 
72
        mock_pywsman.invoke.assert_called_once_with(mock.ANY,
 
73
            namespace, 'ChangeBootOrder')
 
74
 
 
75
        mock_pywsman = mock_client_pywsman.Client.return_value
 
76
        mock_pywsman.invoke.return_value = None
 
77
 
 
78
        self.assertRaises(exception.AMTConnectFailure,
 
79
                          amt_mgmt._set_boot_device_order, self.node, device)
 
80
 
 
81
    def test__enable_boot_config(self, mock_client_pywsman):
 
82
        namespace = resource_uris.CIM_BootService
 
83
        result_xml = test_utils.build_soap_xml([{'ReturnValue': '0'}],
 
84
                                               namespace)
 
85
        mock_xml = test_utils.mock_wsman_root(result_xml)
 
86
        mock_pywsman = mock_client_pywsman.Client.return_value
 
87
        mock_pywsman.invoke.return_value = mock_xml
 
88
 
 
89
        amt_mgmt._enable_boot_config(self.node)
 
90
 
 
91
        mock_pywsman.invoke.assert_called_once_with(mock.ANY,
 
92
            namespace, 'SetBootConfigRole')
 
93
 
 
94
    def test__enable_boot_config_fail(self, mock_client_pywsman):
 
95
        namespace = resource_uris.CIM_BootService
 
96
        result_xml = test_utils.build_soap_xml([{'ReturnValue': '2'}],
 
97
                                               namespace)
 
98
        mock_xml = test_utils.mock_wsman_root(result_xml)
 
99
        mock_pywsman = mock_client_pywsman.Client.return_value
 
100
        mock_pywsman.invoke.return_value = mock_xml
 
101
 
 
102
        self.assertRaises(exception.AMTFailure,
 
103
                          amt_mgmt._enable_boot_config, self.node)
 
104
        mock_pywsman.invoke.assert_called_once_with(mock.ANY,
 
105
            namespace, 'SetBootConfigRole')
 
106
 
 
107
        mock_pywsman = mock_client_pywsman.Client.return_value
 
108
        mock_pywsman.invoke.return_value = None
 
109
 
 
110
        self.assertRaises(exception.AMTConnectFailure,
 
111
                          amt_mgmt._enable_boot_config, self.node)
 
112
 
 
113
 
 
114
class AMTManagementTestCase(db_base.DbTestCase):
 
115
 
 
116
    def setUp(self):
 
117
        super(AMTManagementTestCase, self).setUp()
 
118
        mgr_utils.mock_the_extension_manager(driver='fake_amt')
 
119
        self.info = INFO_DICT
 
120
        self.node = obj_utils.create_test_node(self.context,
 
121
                                               driver='fake_amt',
 
122
                                               driver_info=self.info)
 
123
 
 
124
    def test_get_properties(self):
 
125
        expected = amt_common.COMMON_PROPERTIES
 
126
        with task_manager.acquire(self.context, self.node.uuid,
 
127
                                  shared=True) as task:
 
128
            self.assertEqual(expected, task.driver.get_properties())
 
129
 
 
130
    @mock.patch.object(amt_common, 'parse_driver_info')
 
131
    def test_validate(self, mock_drvinfo):
 
132
        with task_manager.acquire(self.context, self.node.uuid,
 
133
                                  shared=True) as task:
 
134
            task.driver.management.validate(task)
 
135
            mock_drvinfo.assert_called_once_with(task.node)
 
136
 
 
137
    @mock.patch.object(amt_common, 'parse_driver_info')
 
138
    def test_validate_fail(self, mock_drvinfo):
 
139
        with task_manager.acquire(self.context, self.node.uuid,
 
140
                                  shared=True) as task:
 
141
            mock_drvinfo.side_effect = exception.InvalidParameterValue('x')
 
142
            self.assertRaises(exception.InvalidParameterValue,
 
143
                              task.driver.management.validate,
 
144
                              task)
 
145
 
 
146
    def test_get_supported_boot_devices(self):
 
147
        expected = [boot_devices.PXE, boot_devices.DISK, boot_devices.CDROM]
 
148
        with task_manager.acquire(self.context, self.node.uuid,
 
149
                                  shared=True) as task:
 
150
            self.assertEqual(
 
151
                sorted(expected),
 
152
                sorted(task.driver.management.get_supported_boot_devices()))
 
153
 
 
154
    def test_set_boot_device_one_time(self):
 
155
        with task_manager.acquire(self.context, self.node.uuid,
 
156
                                  shared=False) as task:
 
157
            task.driver.management.set_boot_device(task, 'pxe')
 
158
            self.assertEqual('pxe',
 
159
                             task.node.driver_internal_info["amt_boot_device"])
 
160
            self.assertFalse(
 
161
                task.node.driver_internal_info["amt_boot_persistent"])
 
162
 
 
163
    def test_set_boot_device_persistent(self):
 
164
        with task_manager.acquire(self.context, self.node.uuid,
 
165
                                  shared=False) as task:
 
166
            task.driver.management.set_boot_device(task, 'pxe',
 
167
                                                   persistent=True)
 
168
            self.assertEqual('pxe',
 
169
                             task.node.driver_internal_info["amt_boot_device"])
 
170
            self.assertTrue(
 
171
                task.node.driver_internal_info["amt_boot_persistent"])
 
172
 
 
173
    def test_set_boot_device_fail(self):
 
174
        with task_manager.acquire(self.context, self.node.uuid,
 
175
                                  shared=False) as task:
 
176
            self.assertRaises(exception.InvalidParameterValue,
 
177
                              task.driver.management.set_boot_device,
 
178
                              task, 'fake-device')
 
179
 
 
180
    @mock.patch.object(amt_mgmt, '_enable_boot_config')
 
181
    @mock.patch.object(amt_mgmt, '_set_boot_device_order')
 
182
    def test_ensure_next_boot_device_one_time(self, mock_sbdo, mock_ebc):
 
183
        with task_manager.acquire(self.context, self.node.uuid,
 
184
                                  shared=True) as task:
 
185
            device = boot_devices.PXE
 
186
            task.node.driver_internal_info['amt_boot_device'] = 'pxe'
 
187
            task.driver.management.ensure_next_boot_device(task.node, device)
 
188
            self.assertEqual('disk',
 
189
                             task.node.driver_internal_info["amt_boot_device"])
 
190
            self.assertTrue(
 
191
                task.node.driver_internal_info["amt_boot_persistent"])
 
192
            mock_sbdo.assert_called_once_with(task.node, device)
 
193
            mock_ebc.assert_called_once_with(task.node)
 
194
 
 
195
    @mock.patch.object(amt_mgmt, '_enable_boot_config')
 
196
    @mock.patch.object(amt_mgmt, '_set_boot_device_order')
 
197
    def test_ensure_next_boot_device_persistent(self, mock_sbdo, mock_ebc):
 
198
        with task_manager.acquire(self.context, self.node.uuid,
 
199
                                  shared=True) as task:
 
200
            device = boot_devices.PXE
 
201
            task.node.driver_internal_info['amt_boot_device'] = 'pxe'
 
202
            task.node.driver_internal_info['amt_boot_persistent'] = True
 
203
            task.driver.management.ensure_next_boot_device(task.node, device)
 
204
            self.assertEqual('pxe',
 
205
                             task.node.driver_internal_info["amt_boot_device"])
 
206
            self.assertTrue(
 
207
                task.node.driver_internal_info["amt_boot_persistent"])
 
208
            mock_sbdo.assert_called_once_with(task.node, device)
 
209
            mock_ebc.assert_called_once_with(task.node)
 
210
 
 
211
    def test_get_boot_device(self):
 
212
        expected = {'boot_device': boot_devices.DISK, 'persistent': True}
 
213
        with task_manager.acquire(self.context, self.node.uuid,
 
214
                                  shared=True) as task:
 
215
            self.assertEqual(expected,
 
216
                             task.driver.management.get_boot_device(task))
 
217
 
 
218
    def test_get_sensor_data(self):
 
219
        with task_manager.acquire(self.context, self.node.uuid,
 
220
                                  shared=True) as task:
 
221
            self.assertRaises(NotImplementedError,
 
222
                              task.driver.management.get_sensors_data,
 
223
                              task)