openstack
/
shade
Code Issues Proposed changes

Migrate machine tests related to state transitions 

Migrating the machine tests where state transitions
occur, such as turning power on/off, maintenance mode,
hardware inspection, and general provision state changes
such as activating a node and deactivating a node.

Change-Id: I88663fecb79247d5473c47847f9c7405f447a80d
This commit is contained in:
Julia Kreger 2017-09-08 18:53:52 +00:00
parent c821c977b9
commit b817f47782
2 changed files with 332 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
shade/tests/unit/test_baremetal_node.py
View File

@ -486,6 +486,338 @@ class TestBaremetalNode(base.IronicTestCase):
self.assert_calls()
def test_set_machine_maintenace_state(self):
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'maintenance']),
validate=dict(json={'reason': 'no reason'})),
])
self.op_cloud.set_machine_maintenance_state(
self.fake_baremetal_node['uuid'], True, reason='no reason')
self.assert_calls()
def test_set_machine_maintenace_state_false(self):
self.register_uris([
dict(
method='DELETE',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'maintenance'])),
])
self.op_cloud.set_machine_maintenance_state(
self.fake_baremetal_node['uuid'], False)
self.assert_calls
def test_remove_machine_from_maintenance(self):
self.register_uris([
dict(
method='DELETE',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'maintenance'])),
])
self.op_cloud.remove_machine_from_maintenance(
self.fake_baremetal_node['uuid'])
self.assert_calls()
def test_set_machine_power_on(self):
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'power']),
validate=dict(json={'target': 'power on'})),
])
return_value = self.op_cloud.set_machine_power_on(
self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value)
self.assert_calls()
def test_set_machine_power_off(self):
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'power']),
validate=dict(json={'target': 'power off'})),
])
return_value = self.op_cloud.set_machine_power_off(
self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value)
self.assert_calls()
def test_set_machine_power_reboot(self):
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'power']),
validate=dict(json={'target': 'rebooting'})),
])
return_value = self.op_cloud.set_machine_power_reboot(
self.fake_baremetal_node['uuid'])
self.assertIsNone(return_value)
self.assert_calls()
def test_set_machine_power_reboot_failure(self):
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'power']),
status_code=400,
json={'error': 'invalid'},
validate=dict(json={'target': 'rebooting'})),
])
self.assertRaises(exc.OpenStackCloudException,
self.op_cloud.set_machine_power_reboot,
self.fake_baremetal_node['uuid'])
self.assert_calls()
def test_node_set_provision_state(self):
deploy_node = self.fake_baremetal_node.copy()
deploy_node['provision_state'] = 'deploying'
active_node = self.fake_baremetal_node.copy()
active_node['provision_state'] = 'active'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active',
'configdrive': 'http://host/file'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
self.op_cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'],
'active',
configdrive='http://host/file')
self.assert_calls()
def test_node_set_provision_state_wait_timeout(self):
deploy_node = self.fake_baremetal_node.copy()
deploy_node['provision_state'] = 'deploying'
active_node = self.fake_baremetal_node.copy()
active_node['provision_state'] = 'active'
self.fake_baremetal_node['provision_state'] = 'available'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=deploy_node),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=active_node),
])
return_value = self.op_cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'],
'active',
wait=True)
self.assertEqual(active_node, return_value)
self.assert_calls()
def test_node_set_provision_state_wait_timeout_fails(self):
# Intentionally time out.
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
self.assertRaises(
exc.OpenStackCloudException,
self.op_cloud.node_set_provision_state,
self.fake_baremetal_node['uuid'],
'active',
wait=True,
timeout=0.001)
self.assert_calls()
def test_node_set_provision_state_wait_success(self):
self.fake_baremetal_node['provision_state'] = 'active'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
return_value = self.op_cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'],
'active',
wait=True)
self.assertEqual(self.fake_baremetal_node, return_value)
self.assert_calls()
def test_node_set_provision_state_wait_failure_cases(self):
self.fake_baremetal_node['provision_state'] = 'foo failed'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
self.assertRaises(
exc.OpenStackCloudException,
self.op_cloud.node_set_provision_state,
self.fake_baremetal_node['uuid'],
'active',
wait=True,
timeout=300)
self.assert_calls()
def test_node_set_provision_state_wait_provide(self):
self.fake_baremetal_node['provision_state'] = 'manageable'
available_node = self.fake_baremetal_node.copy()
available_node['provision_state'] = 'available'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'provide'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=available_node),
])
return_value = self.op_cloud.node_set_provision_state(
self.fake_baremetal_node['uuid'],
'provide',
wait=True)
self.assertEqual(available_node, return_value)
self.assert_calls()
def test_activate_node(self):
self.fake_baremetal_node['provision_state'] = 'active'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'active',
'configdrive': 'http://host/file'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
return_value = self.op_cloud.activate_node(
self.fake_baremetal_node['uuid'],
configdrive='http://host/file',
wait=True)
self.assertIsNone(return_value)
self.assert_calls()
def test_deactivate_node(self):
self.fake_baremetal_node['provision_state'] = 'available'
self.register_uris([
dict(
method='PUT',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid'],
'states', 'provision']),
validate=dict(json={'target': 'deleted'})),
dict(method='GET',
uri=self.get_mock_url(
resource='nodes',
append=[self.fake_baremetal_node['uuid']]),
json=self.fake_baremetal_node),
])
return_value = self.op_cloud.deactivate_node(
self.fake_baremetal_node['uuid'],
wait=True)
self.assertIsNone(return_value)
self.assert_calls()
def _test_update_machine(self, fake_node, field_name, changed=True):
# The model has evolved over time, create the field if
# we don't already have it.

300
shade/tests/unit/test_shade_operator.py
View File

@ -297,306 +297,6 @@ class TestShadeOperator(base.RequestsMockTestCase):
self.assertTrue(mock_client.port.get_by_address.called)
self.assertTrue(mock_client.node.get.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_maintenace_state(self, mock_client):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
reason = 'no reason'
self.op_cloud.set_machine_maintenance_state(
node_id, True, reason=reason)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='true',
maint_reason='no reason')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_maintenace_state_false(self, mock_client):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
self.op_cloud.set_machine_maintenance_state(node_id, False)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='false')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_remove_machine_from_maintenance(self, mock_client):
mock_client.node.set_maintenance.return_value = None
node_id = 'node01'
self.op_cloud.remove_machine_from_maintenance(node_id)
mock_client.node.set_maintenance.assert_called_with(
node_id='node01',
state='false')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_power_on(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.op_cloud.set_machine_power_on(node_id)
self.assertIsNone(return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
state='on')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_power_off(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.op_cloud.set_machine_power_off(node_id)
self.assertIsNone(return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
state='off')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_power_reboot(self, mock_client):
mock_client.node.set_power_state.return_value = None
node_id = 'node01'
return_value = self.op_cloud.set_machine_power_reboot(node_id)
self.assertIsNone(return_value)
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
state='reboot')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_set_machine_power_reboot_failure(self, mock_client):
mock_client.node.set_power_state.return_value = 'failure'
self.assertRaises(shade.OpenStackCloudException,
self.op_cloud.set_machine_power_reboot,
'node01')
mock_client.node.set_power_state.assert_called_with(
node_id='node01',
state='reboot')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_node_set_provision_state(self, mock_client):
class active_node_state(object):
provision_state = "active"
active_return_value = dict(
provision_state="active")
mock_client.node.set_provision_state.return_value = None
mock_client.node.get.return_value = active_node_state
node_id = 'node01'
return_value = self.op_cloud.node_set_provision_state(
node_id,
'active',
configdrive='http://127.0.0.1/file.iso')
self.assertEqual(active_return_value, return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='active',
configdrive='http://127.0.0.1/file.iso')
self.assertTrue(mock_client.node.get.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_node_set_provision_state_wait_timeout(self, mock_client):
class deploying_node_state(object):
provision_state = "deploying"
class active_node_state(object):
provision_state = "active"
class managable_node_state(object):
provision_state = "managable"
class available_node_state(object):
provision_state = "available"
active_return_value = dict(
provision_state="active")
mock_client.node.get.return_value = active_node_state
mock_client.node.set_provision_state.return_value = None
node_id = 'node01'
return_value = self.op_cloud.node_set_provision_state(
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
wait=True)
self.assertEqual(active_return_value, return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='active',
configdrive='http://127.0.0.1/file.iso')
self.assertTrue(mock_client.node.get.called)
mock_client.mock_reset()
mock_client.node.get.return_value = deploying_node_state
self.assertRaises(
shade.OpenStackCloudException,
self.op_cloud.node_set_provision_state,
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
wait=True,
timeout=0.001)
self.assertTrue(mock_client.node.get.called)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='active',
configdrive='http://127.0.0.1/file.iso')
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_node_set_provision_state_wait_failure(self, mock_client):
class active_node_state(object):
provision_state = "active"
class deploy_failed_node_state(object):
provision_state = "deploy failed"
class clean_failed_node_state(object):
provision_state = "clean failed"
active_return_value = dict(
provision_state="active")
mock_client.node.get.return_value = active_node_state
mock_client.node.set_provision_state.return_value = None
node_id = 'node01'
return_value = self.op_cloud.node_set_provision_state(
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
wait=True)
self.assertEqual(active_return_value, return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='active',
configdrive='http://127.0.0.1/file.iso')
self.assertTrue(mock_client.node.get.called)
mock_client.mock_reset()
mock_client.node.get.return_value = deploy_failed_node_state
self.assertRaises(
shade.OpenStackCloudException,
self.op_cloud.node_set_provision_state,
node_id,
'active',
configdrive='http://127.0.0.1/file.iso',
wait=True,
timeout=300)
self.assertTrue(mock_client.node.get.called)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='active',
configdrive='http://127.0.0.1/file.iso')
mock_client.mock_reset()
mock_client.node.get.return_value = clean_failed_node_state
self.assertRaises(
shade.OpenStackCloudException,
self.op_cloud.node_set_provision_state,
node_id,
'deleted',
wait=True,
timeout=300)
self.assertTrue(mock_client.node.get.called)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node01',
state='deleted',
configdrive=None)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_node_set_provision_state_wait_provide(self, mock_client):
class managable_node_state(object):
provision_state = "managable"
class available_node_state(object):
provision_state = "available"
node_provide_return_value = dict(
provision_state="available")
mock_client.node.get.side_effect = iter([
managable_node_state,
available_node_state])
return_value = self.op_cloud.node_set_provision_state(
'test_node',
'provide',
wait=True)
self.assertEqual(mock_client.node.get.call_count, 2)
self.assertDictEqual(node_provide_return_value, return_value)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
@mock.patch.object(shade._utils, '_iterate_timeout')
def test_activate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None
node_id = 'node02'
return_value = self.op_cloud.activate_node(
node_id,
configdrive='http://127.0.0.1/file.iso')
self.assertIsNone(return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node02',
state='active',
configdrive='http://127.0.0.1/file.iso')
self.assertFalse(mock_timeout.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_activate_node_timeout(self, mock_client):
class active_node_state(object):
provision_state = 'active'
class available_node_state(object):
provision_state = 'available'
mock_client.node.get.side_effect = iter([
available_node_state,
active_node_state])
mock_client.node.set_provision_state.return_value = None
node_id = 'node04'
return_value = self.op_cloud.activate_node(
node_id,
configdrive='http://127.0.0.1/file.iso',
wait=True,
timeout=2)
self.assertIsNone(return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node04',
state='active',
configdrive='http://127.0.0.1/file.iso')
self.assertEqual(mock_client.node.get.call_count, 2)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
@mock.patch.object(shade._utils, '_iterate_timeout')
def test_deactivate_node(self, mock_timeout, mock_client):
mock_client.node.set_provision_state.return_value = None
node_id = 'node03'
return_value = self.op_cloud.deactivate_node(
node_id, wait=False)
self.assertIsNone(return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node03',
state='deleted',
configdrive=None)
self.assertFalse(mock_timeout.called)
@mock.patch.object(shade.OperatorCloud, 'ironic_client')
def test_deactivate_node_timeout(self, mock_client):
class active_node_state(object):
provision_state = 'active'
class deactivated_node_state(object):
provision_state = 'available'
mock_client.node.get.side_effect = iter([
active_node_state,
deactivated_node_state])
mock_client.node.set_provision_state.return_value = None
node_id = 'node03'
return_value = self.op_cloud.deactivate_node(
node_id, wait=True, timeout=2)
self.assertIsNone(return_value)
mock_client.node.set_provision_state.assert_called_with(
node_uuid='node03',
state='deleted',
configdrive=None)
self.assertEqual(mock_client.node.get.call_count, 2)
@mock.patch.object(shade.OpenStackCloud, '_image_client')
def test_get_image_name(self, mock_client):