def test_node_recover_no_physical_id(self):
node = nodem.Node('node1', PROFILE_ID, None)
action = mock.Mock()
res = node.do_recover(self.context, action)
self.assertFalse(res)
def test_node_recover_mult_rebuild(self, mock_recover, mock_status):
def set_status(*args, **kwargs):
if args[1] == 'ACTIVE':
node.physical_id = new_id
node.data = {'recovery': 'RECREATE'}
node = nodem.Node('node1', PROFILE_ID, '', id='fake')
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
new_id = '166db83b-b4a4-49ef-96a8-6c0fdd882d1a'
mock_recover.return_value = new_id, True
mock_status.side_effect = set_status
mock_check = self.patchobject(pb.Profile, 'check_object')
mock_check.return_value = False
action = mock.Mock(
outputs={}, inputs={'operation': [{'name': 'REBOOT'},
{'name': 'REBUILD'}],
'check': True})
res = node.do_recover(self.context, action)
self.assertTrue(res)
mock_check.assert_called_once_with(self.context, node)
mock_recover.assert_called_once_with(
self.context, node, **action.inputs)
self.assertEqual('node1', node.name)
self.assertEqual(new_id, node.physical_id)
self.assertEqual(PROFILE_ID, node.profile_id)
mock_status.assert_has_calls([
mock.call(self.context, 'RECOVERING',
reason='Recovery in progress'),
mock.call(self.context, consts.NS_ACTIVE,
reason='Recovery succeeded',
physical_id=new_id,
data={'recovery': 'RECREATE'})])
def test_node_recover_new_object(self, mock_recover, mock_status):
def set_status(*args, **kwargs):
if args[1] == 'ACTIVE':
node.physical_id = new_id
node.data = {'recovery': 'RECREATE'}
node = nodem.Node('node1', PROFILE_ID, '')
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
new_id = '166db83b-b4a4-49ef-96a8-6c0fdd882d1a'
# action = node_action.NodeAction(node.id, 'ACTION', self.ctx)
mock_recover.return_value = new_id, True
mock_status.side_effect = set_status
action = mock.Mock()
action.inputs = {'operation': ['SWIM', 'DANCE']}
res = node.do_recover(self.context, action)
self.assertTrue(res)
mock_recover.assert_called_once_with(
self.context, node, **action.inputs)
self.assertEqual('node1', node.name)
self.assertEqual(new_id, node.physical_id)
self.assertEqual(PROFILE_ID, node.profile_id)
self.assertEqual({'recovery': 'RECREATE'}, node.data)
mock_status.assert_has_calls([
mock.call(self.context, 'RECOVERING',
reason='Recovery in progress'),
mock.call(self.context, consts.NS_ACTIVE,
reason='Recovery succeeded',
physical_id=new_id,
data={'recovery': 'RECREATE'})])
def test_node_update_EResourceUpdate(self, mock_db, mock_update):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
node.physical_id = uuidutils.generate_uuid()
node.id = uuidutils.generate_uuid()
ex = exception.EResourceUpdate(type='PROFILE', id='ID',
message='reason')
mock_update.side_effect = ex
new_id = uuidutils.generate_uuid()
utils.create_profile(self.context, new_id)
res = node.do_update(self.context, {'new_profile_id': new_id})
self.assertFalse(res)
self.assertNotEqual(new_id, node.profile_id)
mock_db.assert_has_calls([
mock.call(
self.context, node.id,
{"status": "UPDATING", "status_reason": "Update in progress"}
),
mock.call(
self.context, node.id,
{"status": "ERROR",
"status_reason": "Failed in updating PROFILE 'ID': reason.",
"updated_at": mock.ANY}
)
])
self.assertEqual(1, mock_update.call_count)
def test_node_operation_no_physical_id(self):
node = nodem.Node('node1', PROFILE_ID, None)
inputs = {'operation': 'dance', 'params': {'style': 'tango'}}
res = node.do_operation(self.context, **inputs)
self.assertFalse(res)
def test_node_store_init(self):
node = nodem.Node('node1',
PROFILE_ID,
CLUSTER_ID,
self.context,
role='first_node',
index=1)
self.assertIsNone(node.id)
node_id = node.store(self.context)
self.assertIsNotNone(node_id)
node_info = node_obj.Node.get(self.context, node_id)
self.assertIsNotNone(node_info)
self.assertEqual('node1', node_info.name)
self.assertIsNone(node_info.physical_id)
self.assertEqual(CLUSTER_ID, node_info.cluster_id)
self.assertEqual(PROFILE_ID, node_info.profile_id)
self.assertEqual(self.context.user, node_info.user)
self.assertEqual(self.context.project, node_info.project)
self.assertEqual(self.context.domain, node_info.domain)
self.assertEqual(1, node_info.index)
self.assertEqual('first_node', node.role)
self.assertIsNotNone(node_info.init_at)
self.assertIsNone(node_info.created_at)
self.assertIsNone(node_info.updated_at)
self.assertEqual('INIT', node_info.status)
self.assertEqual('Initializing', node_info.status_reason)
self.assertEqual({}, node_info.metadata)
self.assertEqual({}, node_info.data)
def test_run_workflow_failed_creation(self):
node = nodem.Node('node1', PROFILE_ID, 'FAKE_CLUSTER')
node.physical_id = 'FAKE_NODE'
wfc = mock.Mock()
wfc.workflow_find.return_value = None
err = exception.InternalError(message='boom')
wfc.workflow_create.side_effect = err
wfc.execution_create = mock.Mock()
x_profile = mock.Mock()
x_profile.workflow = mock.Mock(return_value=wfc)
node.rt['profile'] = x_profile
options = {
'workflow_name': 'foo',
'inputs': {
'definition': {'bar': 'baz'},
'FAKE_KEY1': 'FAKE_VALUE1',
'FAKE_KEY2': 'FAKE_VALUE2',
}
}
ex = self.assertRaises(exception.EResourceOperation,
node.run_workflow,
**options)
self.assertEqual("Failed in executing workflow 'foo': boom.",
six.text_type(ex))
x_profile.workflow.assert_called_once_with(node)
wfc.workflow_find.assert_called_once_with('foo')
wfc.workflow_create.assert_called_once_with(
{'bar': 'baz'}, scope='private')
self.assertEqual(0, wfc.execution_create.call_count)
def test_run_workflow_no_physical_id(self):
node = nodem.Node('node1', PROFILE_ID, 'FAKE_CLUSTER')
node.physical_id = None
res = node.run_workflow()
self.assertFalse(res)
def test_node_delete_not_created(self, mock_delete, mock_db_delete):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
self.assertIsNone(node.physical_id)
res = node.do_delete(self.context)
self.assertTrue(res)
self.assertFalse(mock_delete.called)
self.assertTrue(mock_db_delete.called)
def test_node_update_name(self, mock_db, mock_update):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
node.store(self.context)
physical_id = uuidutils.generate_uuid()
node.physical_id = physical_id
res = node.do_update(self.context, {'name': 'new_name',
'role': 'new_role',
'metadata': {'k': {'m': 'v'}},
'bogus': 'foo'})
self.assertTrue(res)
self.assertEqual('new_name', node.name)
mock_db.assert_has_calls([
mock.call(self.context, node.id,
{'status': 'UPDATING',
'status_reason': 'Update in progress'}),
mock.call(self.context, node.id,
{'status': 'ACTIVE',
'status_reason': 'Update succeeded',
'name': 'new_name',
'role': 'new_role',
'metadata': {'k': {'m': 'v'}},
'updated_at': mock.ANY})
])
self.assertEqual(0, mock_update.call_count)
def test_node_init(self):
node = nodem.Node('node1',
self.profile.id,
self.cluster.id,
role='first_node')
self.assertIsNone(node.id)
self.assertEqual('node1', node.name)
self.assertEqual('', node.physical_id)
self.assertEqual(self.profile.id, node.profile_id)
self.assertEqual('', node.user)
self.assertEqual('', node.project)
self.assertEqual('', node.domain)
self.assertEqual(self.cluster.id, node.cluster_id)
self.assertEqual(-1, node.index)
self.assertEqual('first_node', node.role)
self.assertIsNone(node.init_at)
self.assertIsNone(node.created_at)
self.assertIsNone(node.updated_at)
self.assertEqual('INIT', node.status)
self.assertEqual('Initializing', node.status_reason)
self.assertEqual({}, node.data)
self.assertEqual({}, node.metadata)
self.assertEqual({}, node.rt)
def test_run_workflow_workflow_is_found(self):
node = nodem.Node('node1', PROFILE_ID, 'FAKE_CLUSTER')
node.physical_id = 'FAKE_NODE'
wfc = mock.Mock()
wfc.workflow_find.return_value = mock.Mock(definition={'bar': 'baz'})
wfc.workflow_create = mock.Mock()
wfc.execution_create = mock.Mock()
x_profile = mock.Mock()
x_profile.workflow = mock.Mock(return_value=wfc)
node.rt['profile'] = x_profile
options = {
'workflow_name': 'foo',
'inputs': {
'FAKE_KEY1': 'FAKE_VALUE1',
'FAKE_KEY2': 'FAKE_VALUE2',
}
}
res = node.run_workflow(**options)
self.assertTrue(res)
x_profile.workflow.assert_called_once_with(node)
wfc.workflow_find.assert_called_once_with('foo')
self.assertEqual(0, wfc.workflow_create.call_count)
final_dict = {
'cluster_id': 'FAKE_CLUSTER',
'node_id': 'FAKE_NODE',
'FAKE_KEY1': 'FAKE_VALUE1',
'FAKE_KEY2': 'FAKE_VALUE2',
}
self._verify_execution_create_args('foo', final_dict, wfc)
def test_node_recover_operation_not_support(self, mock_set_status):
node = nodem.Node('node1', PROFILE_ID, None)
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
params = {'operation': 'foo'}
res = node.do_recover(self.context, **params)
self.assertFalse(res)
def test_node_delete_not_created(self, mock_delete, mock_db_delete):
node = nodem.Node('node1', self.profile.id, self.cluster.id,
self.context)
self.assertEqual('', node.physical_id)
res = node.do_delete(self.context)
self.assertTrue(res)
self.assertFalse(mock_delete.called)
self.assertTrue(mock_db_delete.called)
def test_node_create_not_init(self, mock_status):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
node.status = 'NOT_INIT'
res, reason = node.do_create(self.context)
self.assertFalse(res)
self.assertEqual('Node must be in INIT status', reason)
mock_status.assert_any_call(self.context, consts.NS_ERROR,
'Node must be in INIT status')
def test_node_join_same_cluster(self, mock_migrate):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
node.index = 1
res = node.do_join(self.context, CLUSTER_ID)
self.assertTrue(res)
self.assertEqual(1, node.index)
self.assertIsNone(node.updated_at)
self.assertFalse(mock_migrate.called)
def test_node_store_update(self):
node = nodem.Node('node1', self.profile.id, None)
node_id = node.store(self.context)
node.name = 'new_name'
new_node_id = node.store(self.context)
self.assertEqual(node_id, new_node_id)
def test_node_recover_operation_not_support(self, mock_set_status):
node = nodem.Node('node1', PROFILE_ID, None)
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
action = mock.Mock(outputs={}, inputs={'operation': [{'name': 'foo'}]})
res = node.do_recover(self.context, action)
self.assertEqual({}, action.outputs)
self.assertFalse(res)
def test_node_healthcheck(self, mock_healthcheck):
node = nodem.Node('node1', PROFILE_ID, '')
node.status = consts.NS_ACTIVE
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
mock_healthcheck.return_value = True
res = node.do_healthcheck(self.context)
self.assertTrue(res)
mock_healthcheck.assert_called_once_with(self.context, node)
def test_node_check_failed_check(self, mock_check, mock_store):
node = nodem.Node('node1', PROFILE_ID, '')
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
mock_check.return_value = False
res = node.do_check(self.context)
self.assertFalse(res)
self.assertEqual('ERROR', node.status)
def test_node_create_not_created(self, mock_create, mock_status):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context)
mock_create.return_value = None
res = node.do_create(self.context)
self.assertFalse(res)
mock_status.assert_called_once_with(self.context,
node.CREATING,
reason='Creation in progress')
def test_node_leave_fail_update_server_metadata(self, mock_leave):
node = nodem.Node('node1', PROFILE_ID, CLUSTER_ID, self.context,
index=1)
mock_leave.return_value = False
res = node.do_leave(self.context)
self.assertFalse(res)
self.assertNotEqual('', node.cluster_id)
self.assertIsNone(node.updated_at)
self.assertEqual(1, node.index)
def test_node_store_update(self):
node = nodem.Node('node1', PROFILE_ID, "", user=self.context.user_id,
project=self.context.project_id)
node_id = node.store(self.context)
node.name = 'new_name'
new_node_id = node.store(self.context)
self.assertEqual(node_id, new_node_id)
def test_create_with_obj(self):
params = copy.deepcopy(self.params)
name = params.pop('name')
profile_id = params.pop('profile_id')
n1 = node.Node(name, profile_id, **params)
sot = base.NodePayload.from_node(n1)
self._verify_equality(sot, self.params)
def test_node_check_failed_check(self, mock_check, mock_store):
node = nodem.Node('node1', self.profile.id, '')
node.physical_id = 'fake_id'
mock_check.return_value = False
res = node.do_check(self.context)
self.assertFalse(res)
self.assertEqual('ERROR', node.status)
def test_node_check(self, mock_check):
node = nodem.Node('node1', self.profile.id, '')
node.physical_id = 'fake_id'
mock_check.return_value = True
res = node.do_check(self.context)
self.assertTrue(res)
mock_check.assert_called_once_with(self.context, node)
def test_node_join_fail_update_server_metadata(self, mock_join):
node = nodem.Node('node1', self.profile.id, None, self.context)
mock_join.return_value = False
res = node.do_join(self.context, 'NEW_CLUSTER_ID')
self.assertFalse(res)
self.assertEqual('', node.cluster_id)
self.assertEqual(-1, node.index)
self.assertIsNone(node.updated_at)
mock_join.assert_called_once_with(self.context, node, 'NEW_CLUSTER_ID')
def test_node_join_same_cluster(self, mock_migrate):
node = nodem.Node('node1', self.profile.id, self.cluster.id,
self.context)
node.index = 1
res = node.do_join(self.context, self.cluster.id)
self.assertTrue(res)
self.assertEqual(1, node.index)
self.assertIsNone(node.updated_at)
self.assertFalse(mock_migrate.called)
def test_node_join_fail_update_server_metadata(self, mock_join):
node = nodem.Node('node1', PROFILE_ID, None, self.context)
mock_join.return_value = False
cluster_id = 'fb8bca7a-a82b-4442-a40f-92d3e3cfb0b9'
res = node.do_join(self.context, cluster_id)
self.assertFalse(res)
self.assertEqual('', node.cluster_id)
self.assertEqual(-1, node.index)
self.assertIsNone(node.updated_at)
mock_join.assert_called_once_with(self.context, node, cluster_id)
def test_node_check_check_return_false(self, mock_check, mock_status):
node = nodem.Node('node1', PROFILE_ID, '')
node.physical_id = 'd94d6333-82e6-4f87-b7ab-b786776df9d1'
mock_check.return_value = False
res = node.do_check(self.context)
self.assertFalse(res)
mock_status.assert_called_once_with(self.context, consts.NS_ERROR,
'Check: Node is not ACTIVE.')
