def test_from_db_record(self):
values = copy.deepcopy(self.action_values)
obj = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx, **values)
obj.store(self.ctx)
record = ao.Action.get(self.ctx, obj.id)
action_obj = ab.Action._from_object(record)
self.assertIsInstance(action_obj, ab.Action)
self.assertEqual(obj.id, action_obj.id)
self.assertEqual(obj.action, action_obj.action)
self.assertEqual(obj.name, action_obj.name)
self.assertEqual(obj.target, action_obj.target)
self.assertEqual(obj.cause, action_obj.cause)
self.assertEqual(obj.owner, action_obj.owner)
self.assertEqual(obj.interval, action_obj.interval)
self.assertEqual(obj.start_time, action_obj.start_time)
self.assertEqual(obj.end_time, action_obj.end_time)
self.assertEqual(obj.timeout, action_obj.timeout)
self.assertEqual(obj.status, action_obj.status)
self.assertEqual(obj.status_reason, action_obj.status_reason)
self.assertEqual(obj.inputs, action_obj.inputs)
self.assertEqual(obj.outputs, action_obj.outputs)
self.assertEqual(common_utils.isotime(obj.created_at),
common_utils.isotime(action_obj.created_at))
self.assertEqual(obj.updated_at, action_obj.updated_at)
self.assertEqual(obj.data, action_obj.data)
self.assertEqual(obj.user, action_obj.user)
self.assertEqual(obj.project, action_obj.project)
self.assertEqual(obj.domain, action_obj.domain)
def to_dict(self):
context = senlin_context.get_admin_context()
profile = db_api.profile_get(context,
self.profile_id,
project_safe=False)
return {
'id': self.id,
'name': self.name,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'min_size': self.min_size,
'max_size': self.max_size,
'desired_capacity': self.desired_capacity,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'metadata': self.metadata or {},
'data': self.data or {},
'dependents': self.dependents or {},
'profile_name': profile.name,
'nodes': db_api.node_ids_by_cluster(context, self.id),
'policies': db_api.cluster_policy_ids_by_cluster(context, self.id)
}
def to_dict(self):
if self.id:
dep_on = dobj.Dependency.get_depended(self.context, self.id)
dep_by = dobj.Dependency.get_dependents(self.context, self.id)
else:
dep_on = []
dep_by = []
action_dict = {
'id': self.id,
'name': self.name,
'action': self.action,
'target': self.target,
'cause': self.cause,
'owner': self.owner,
'interval': self.interval,
'start_time': self.start_time,
'end_time': self.end_time,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'inputs': self.inputs,
'outputs': self.outputs,
'depends_on': dep_on,
'depended_by': dep_by,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'data': self.data,
'user': self.user,
'project': self.project,
}
return action_dict
def test_receiver_store(self):
receiver = rb.Receiver('webhook', CLUSTER_ID, 'test-action',
name='test_receiver_123456',
project=self.context.project)
self.assertIsNone(receiver.id)
receiver_id = receiver.store(self.context)
self.assertIsNotNone(receiver_id)
self.assertEqual(receiver_id, receiver.id)
result = ro.Receiver.get(self.context, receiver_id)
self.assertIsNotNone(result)
self.assertEqual(receiver_id, result.id)
self.assertEqual(receiver.type, result.type)
self.assertEqual(receiver.name, result.name)
self.assertEqual(receiver.user, result.user)
self.assertEqual(receiver.project, result.project)
self.assertEqual(receiver.domain, result.domain)
self.assertEqual(common_utils.isotime(receiver.created_at),
common_utils.isotime(result.created_at)),
self.assertEqual(receiver.updated_at, result.updated_at)
self.assertEqual(receiver.action, result.action)
self.assertEqual(receiver.actor, result.actor)
self.assertEqual(receiver.params, result.params)
self.assertEqual(receiver.channel, result.channel)
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'min_size': self.min_size,
'max_size': self.max_size,
'desired_capacity': self.desired_capacity,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'metadata': self.metadata or {},
'data': self.data or {},
'dependents': self.dependents or {},
'config': self.config or {},
'profile_name': self.profile_name,
'nodes': self.nodes,
'policies': self.policies
}
def test_from_db_record(self):
values = copy.deepcopy(self.action_values)
obj = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx, **values)
obj.store(self.ctx)
record = ao.Action.get(self.ctx, obj.id)
action_obj = ab.Action._from_object(record)
self.assertIsInstance(action_obj, ab.Action)
self.assertEqual(obj.id, action_obj.id)
self.assertEqual(obj.action, action_obj.action)
self.assertEqual(obj.name, action_obj.name)
self.assertEqual(obj.target, action_obj.target)
self.assertEqual(obj.cause, action_obj.cause)
self.assertEqual(obj.owner, action_obj.owner)
self.assertEqual(obj.interval, action_obj.interval)
self.assertEqual(obj.start_time, action_obj.start_time)
self.assertEqual(obj.end_time, action_obj.end_time)
self.assertEqual(obj.timeout, action_obj.timeout)
self.assertEqual(obj.status, action_obj.status)
self.assertEqual(obj.status_reason, action_obj.status_reason)
self.assertEqual(obj.inputs, action_obj.inputs)
self.assertEqual(obj.outputs, action_obj.outputs)
self.assertEqual(common_utils.isotime(obj.created_at),
common_utils.isotime(action_obj.created_at))
self.assertEqual(obj.updated_at, action_obj.updated_at)
self.assertEqual(obj.data, action_obj.data)
self.assertEqual(obj.user, action_obj.user)
self.assertEqual(obj.project, action_obj.project)
self.assertEqual(obj.domain, action_obj.domain)
def test_node_to_dict_no_profile(self, mock_profile_get):
x_node_id = '11ad5c3d-e1e5-4ed8-8fe3-2938b63a11cb'
node = utils.create_node(self.context, x_node_id, PROFILE_ID,
CLUSTER_ID)
self.assertIsNotNone(node.id)
expected = {
'id': node.id,
'name': node.name,
'cluster_id': node.cluster_id,
'physical_id': node.physical_id,
'profile_id': node.profile_id,
'user': node.user,
'project': node.project,
'domain': node.domain,
'index': node.index,
'role': node.role,
'init_at': common_utils.isotime(node.init_at),
'created_at': common_utils.isotime(node.created_at),
'updated_at': common_utils.isotime(node.updated_at),
'status': node.status,
'status_reason': node.status_reason,
'data': node.data,
'metadata': node.metadata,
'profile_name': 'Unknown',
}
mock_profile_get.return_value = None
result = nodem.Node.load(self.context, x_node_id)
dt = result.to_dict()
self.assertEqual(expected, dt)
def to_dict(self):
if self.id:
dep_on = dobj.Dependency.get_depended(self.context, self.id)
dep_by = dobj.Dependency.get_dependents(self.context, self.id)
else:
dep_on = []
dep_by = []
action_dict = {
'id': self.id,
'name': self.name,
'action': self.action,
'target': self.target,
'cause': self.cause,
'owner': self.owner,
'interval': self.interval,
'start_time': self.start_time,
'end_time': self.end_time,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'inputs': self.inputs,
'outputs': self.outputs,
'depends_on': dep_on,
'depended_by': dep_by,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'data': self.data,
}
return action_dict
def test_node_to_dict(self):
x_node_id = '16e70db8-4f70-4883-96be-cf40264a5abd'
node = utils.create_node(self.context, x_node_id, PROFILE_ID,
CLUSTER_ID)
self.assertIsNotNone(node.id)
expected = {
'id': node.id,
'name': node.name,
'cluster_id': node.cluster_id,
'physical_id': node.physical_id,
'profile_id': node.profile_id,
'user': node.user,
'project': node.project,
'domain': node.domain,
'index': node.index,
'role': node.role,
'init_at': common_utils.isotime(node.init_at),
'created_at': common_utils.isotime(node.created_at),
'updated_at': common_utils.isotime(node.updated_at),
'status': node.status,
'status_reason': node.status_reason,
'data': node.data,
'metadata': node.metadata,
'dependents': node.dependents,
'profile_name': self.profile.name,
}
result = nodem.Node.load(self.context, x_node_id)
dt = result.to_dict()
self.assertEqual(expected, dt)
def test_receiver_store(self):
receiver = rb.Receiver('webhook',
CLUSTER_ID,
'test-action',
name='test_receiver_123456',
project=self.context.project)
self.assertIsNone(receiver.id)
receiver_id = receiver.store(self.context)
self.assertIsNotNone(receiver_id)
self.assertEqual(receiver_id, receiver.id)
result = ro.Receiver.get(self.context, receiver_id)
self.assertIsNotNone(result)
self.assertEqual(receiver_id, result.id)
self.assertEqual(receiver.type, result.type)
self.assertEqual(receiver.name, result.name)
self.assertEqual(receiver.user, result.user)
self.assertEqual(receiver.project, result.project)
self.assertEqual(receiver.domain, result.domain)
self.assertEqual(common_utils.isotime(receiver.created_at),
common_utils.isotime(result.created_at)),
self.assertEqual(receiver.updated_at, result.updated_at)
self.assertEqual(receiver.action, result.action)
self.assertEqual(receiver.actor, result.actor)
self.assertEqual(receiver.params, result.params)
self.assertEqual(receiver.channel, result.channel)
def to_dict(self):
action_dict = {
'id': self.id,
'name': self.name,
'action': self.action,
'target': self.target,
'cause': self.cause,
'owner': self.owner,
'interval': self.interval,
'start_time': self.start_time,
'end_time': self.end_time,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'inputs': self.inputs,
'outputs': self.outputs,
'depends_on': self.dep_on,
'depended_by': self.dep_by,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'data': self.data,
'user': self.user,
'project': self.project,
}
return action_dict
def to_dict(self):
info = {
'id': self.id,
'name': self.name,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'min_size': self.min_size,
'max_size': self.max_size,
'desired_capacity': self.desired_capacity,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'metadata': self.metadata,
'data': self.data,
'dependents': self.dependents,
'nodes': [node.id for node in self.rt['nodes']],
'policies': [policy.id for policy in self.rt['policies']],
}
if self.rt['profile']:
info['profile_name'] = self.rt['profile'].name
else:
info['profile_name'] = None
return info
def test_node_to_dict(self):
x_node_id = '16e70db8-4f70-4883-96be-cf40264a5abd'
node = utils.create_node(self.context, x_node_id, PROFILE_ID,
CLUSTER_ID)
self.assertIsNotNone(node.id)
expected = {
'id': node.id,
'name': node.name,
'cluster_id': node.cluster_id,
'physical_id': node.physical_id,
'profile_id': node.profile_id,
'user': node.user,
'project': node.project,
'domain': node.domain,
'index': node.index,
'role': node.role,
'init_at': common_utils.isotime(node.init_at),
'created_at': common_utils.isotime(node.created_at),
'updated_at': common_utils.isotime(node.updated_at),
'status': node.status,
'status_reason': node.status_reason,
'data': node.data,
'metadata': node.metadata,
'profile_name': self.profile.name,
}
result = nodem.Node.load(self.context, x_node_id)
dt = result.to_dict()
self.assertEqual(expected, dt)
def test_node_to_dict_no_profile(self, mock_profile_get):
x_node_id = '11ad5c3d-e1e5-4ed8-8fe3-2938b63a11cb'
node = utils.create_node(self.context, x_node_id, PROFILE_ID,
CLUSTER_ID)
self.assertIsNotNone(node.id)
expected = {
'id': node.id,
'name': node.name,
'cluster_id': node.cluster_id,
'physical_id': node.physical_id,
'profile_id': node.profile_id,
'user': node.user,
'project': node.project,
'domain': node.domain,
'index': node.index,
'role': node.role,
'init_at': common_utils.isotime(node.init_at),
'created_at': common_utils.isotime(node.created_at),
'updated_at': common_utils.isotime(node.updated_at),
'status': node.status,
'status_reason': node.status_reason,
'data': node.data,
'metadata': node.metadata,
'dependents': node.dependents,
'profile_name': 'Unknown',
}
mock_profile_get.return_value = None
result = nodem.Node.load(self.context, x_node_id)
dt = result.to_dict()
self.assertEqual(expected, dt)
def to_dict(self):
if self.rt['profile']:
profile_name = self.rt['profile'].name
else:
profile_name = 'Unknown'
node_dict = {
'id': self.id,
'name': self.name,
'cluster_id': self.cluster_id,
'physical_id': self.physical_id,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'index': self.index,
'role': self.role,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'status': self.status,
'status_reason': self.status_reason,
'data': self.data,
'metadata': self.metadata,
'profile_name': profile_name,
}
return node_dict
def to_dict(self):
if self.rt['profile']:
profile_name = self.rt['profile'].name
else:
profile_name = 'Unknown'
node_dict = {
'id': self.id,
'name': self.name,
'cluster_id': self.cluster_id,
'physical_id': self.physical_id,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'index': self.index,
'role': self.role,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'status': self.status,
'status_reason': self.status_reason,
'data': self.data,
'metadata': self.metadata,
'profile_name': profile_name,
}
return node_dict
def to_dict(self):
info = {
'id': self.id,
'name': self.name,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'min_size': self.min_size,
'max_size': self.max_size,
'desired_capacity': self.desired_capacity,
'timeout': self.timeout,
'status': self.status,
'status_reason': self.status_reason,
'metadata': self.metadata,
'data': self.data,
'nodes': [node.id for node in self.rt['nodes']],
'policies': [policy.id for policy in self.rt['policies']],
}
if self.rt['profile']:
info['profile_name'] = self.rt['profile'].name
else:
info['profile_name'] = None
return info
def test_action_store_for_create(self):
values = copy.deepcopy(self.action_values)
obj = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx, **values)
self.assertEqual(common_utils.isotime(values['created_at']),
common_utils.isotime(obj.created_at))
self.assertIsNone(obj.updated_at)
# store for creation
res = obj.store(self.ctx)
self.assertIsNotNone(res)
self.assertEqual(obj.id, res)
self.assertIsNotNone(obj.created_at)
self.assertIsNone(obj.updated_at)
def to_dict(self):
pb_dict = {
'id': self.id,
'name': self.name,
'type': self.type,
'user': self.user,
'project': self.project,
'domain': self.domain,
'spec': self.spec,
'metadata': self.metadata,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
}
return pb_dict
def to_dict(self):
pb_dict = {
'id': self.id,
'name': self.name,
'type': self.type,
'user': self.user,
'project': self.project,
'domain': self.domain,
'spec': self.spec,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'data': self.data,
}
return pb_dict
def test_action_store_for_create(self):
values = copy.deepcopy(self.action_values)
obj = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx, **values)
self.assertEqual(common_utils.isotime(values['created_at']),
common_utils.isotime(obj.created_at))
self.assertIsNone(obj.updated_at)
# store for creation
res = obj.store(self.ctx)
self.assertIsNotNone(res)
self.assertEqual(obj.id, res)
self.assertIsNotNone(obj.created_at)
self.assertIsNone(obj.updated_at)
def test_action_to_dict(self, mock_dep_by, mock_dep_on):
mock_dep_on.return_value = ['ACTION_1']
mock_dep_by.return_value = ['ACTION_2']
action = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx,
**self.action_values)
action.id = 'FAKE_ID'
ts = common_utils.isotime(self.action_values['created_at'])
expected = {
'id': 'FAKE_ID',
'name': 'FAKE_NAME',
'action': 'OBJECT_ACTION',
'target': OBJID,
'cause': 'FAKE_CAUSE',
'owner': OWNER_ID,
'interval': 60,
'start_time': 0,
'end_time': 0,
'timeout': 120,
'status': 'FAKE_STATUS',
'status_reason': 'FAKE_STATUS_REASON',
'inputs': {'param': 'value'},
'outputs': {'key': 'output_value'},
'depends_on': ['ACTION_1'],
'depended_by': ['ACTION_2'],
'created_at': ts,
'updated_at': None,
'data': {'data_key': 'data_value'},
}
res = action.to_dict()
self.assertEqual(expected, res)
mock_dep_on.assert_called_once_with(action.context, 'FAKE_ID')
mock_dep_by.assert_called_once_with(action.context, 'FAKE_ID')
def to_dict(self):
info = {
'id': self.id,
'name': self.name,
'type': self.type,
'user': self.user,
'project': self.project,
'domain': self.domain,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'cluster_id': self.cluster_id,
'actor': self.actor,
'action': self.action,
'params': self.params,
'channel': self.channel,
}
return info
def to_dict(self):
receiver_dict = {
'id': self.id,
'name': self.name,
'type': self.type,
'user': self.user,
'project': self.project,
'domain': self.domain,
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'cluster_id': self.cluster_id,
'actor': self.actor,
'action': self.action,
'params': self.params,
'channel': self.channel,
}
return receiver_dict
def test_event_create_get(self):
event = self.create_event(self.ctx)
ret_event = db_api.event_get(self.ctx, event.id)
self.assertIsNotNone(ret_event)
tst_timestamp = tu.parse_strtime('2014-12-19 11:51:54.670244',
'%Y-%m-%d %H:%M:%S.%f')
self.assertEqual(common_utils.isotime(tst_timestamp),
common_utils.isotime(ret_event.timestamp))
self.assertEqual('20', ret_event.level)
self.assertEqual('', ret_event.oid)
self.assertEqual('', ret_event.otype)
self.assertEqual('', ret_event.oname)
self.assertEqual('', ret_event.action)
self.assertEqual('', ret_event.status)
self.assertEqual('', ret_event.status_reason)
self.assertEqual(self.ctx.user, ret_event.user)
self.assertEqual(self.ctx.project, ret_event.project)
def test_to_dict(self):
PROFILE_ID = uuidutils.generate_uuid()
CLUSTER_ID = uuidutils.generate_uuid()
values = {
'name': 'test_node',
'profile_id': PROFILE_ID,
'cluster_id': CLUSTER_ID,
'user': self.ctx.user_id,
'project': self.ctx.project_id,
'index': -1,
'init_at': timeutils.utcnow(True),
'status': 'Initializing',
}
node = no.Node.create(self.ctx, values)
self.assertIsNotNone(node.id)
expected = {
'id': node.id,
'name': node.name,
'cluster_id': node.cluster_id,
'physical_id': node.physical_id,
'profile_id': node.profile_id,
'user': node.user,
'project': node.project,
'domain': node.domain,
'index': node.index,
'role': node.role,
'init_at': common_utils.isotime(node.init_at),
'created_at': common_utils.isotime(node.created_at),
'updated_at': common_utils.isotime(node.updated_at),
'status': node.status,
'status_reason': node.status_reason,
'data': node.data,
'metadata': node.metadata,
'dependents': node.dependents,
'profile_name': node.profile_name,
'tainted': False,
}
result = no.Node.get(self.ctx, node.id)
dt = result.to_dict()
self.assertEqual(expected, dt)
def test_receiver_to_dict(self):
receiver = self._create_receiver('test-receiver', UUID1)
self.assertIsNotNone(receiver.id)
expected = {
'id': receiver.id,
'name': receiver.name,
'type': receiver.type,
'user': receiver.user,
'project': receiver.project,
'domain': receiver.domain,
'cluster_id': receiver.cluster_id,
'action': receiver.action,
'actor': receiver.actor,
'params': receiver.params,
'created_at': common_utils.isotime(receiver.created_at),
'updated_at': common_utils.isotime(receiver.updated_at),
'channel': None,
}
result = rb.Receiver.load(self.context, receiver_id=receiver.id)
self.assertEqual(expected, result.to_dict())
def test_receiver_to_dict(self):
receiver = self._create_receiver('test-receiver', UUID1)
self.assertIsNotNone(receiver.id)
expected = {
'id': receiver.id,
'name': receiver.name,
'type': receiver.type,
'user': receiver.user,
'project': receiver.project,
'domain': receiver.domain,
'cluster_id': receiver.cluster_id,
'action': receiver.action,
'actor': receiver.actor,
'params': receiver.params,
'created_at': common_utils.isotime(receiver.created_at),
'updated_at': common_utils.isotime(receiver.updated_at),
'channel': None,
}
result = rb.Receiver.load(self.context, receiver_id=receiver.id)
self.assertEqual(expected, result.to_dict())
def test_cluster_policy_store(self):
utils.create_profile(self.context, PROFILE_ID)
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
self.assertIsNone(cp.id)
cp_id = cp.store(self.context)
self.assertIsNotNone(cp_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertEqual(12, result.priority)
self.assertTrue(result.enabled)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
# do an update
cp.enabled = False
cp.priority = 60
cp.data = {'foo': 'bar'}
timestamp = timeutils.utcnow(True)
cp.last_op = timestamp
new_id = cp.store(self.context)
self.assertEqual(cp_id, new_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertFalse(result.enabled)
self.assertEqual(60, result.priority)
self.assertEqual({'foo': 'bar'}, result.data)
self.assertEqual(common_utils.isotime(timestamp),
common_utils.isotime(result.last_op))
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'cluster_id': self.cluster_id,
'physical_id': self.physical_id,
'profile_id': self.profile_id,
'user': self.user,
'project': self.project,
'domain': self.domain,
'index': self.index,
'role': self.role,
'init_at': utils.isotime(self.init_at),
'created_at': utils.isotime(self.created_at),
'updated_at': utils.isotime(self.updated_at),
'status': self.status,
'status_reason': self.status_reason,
'data': self.data,
'metadata': self.metadata,
'dependents': self.dependents,
'profile_name': self.profile_name,
}
def test_cluster_policy_store(self):
cluster = utils.create_cluster(self.context, CLUSTER_ID, PROFILE_ID)
policy = utils.create_policy(self.context, POLICY_ID)
values = {
'priority': 12,
'enabled': True,
}
cp = cpm.ClusterPolicy(cluster.id, policy.id, **values)
self.assertIsNone(cp.id)
cp_id = cp.store(self.context)
self.assertIsNotNone(cp_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertEqual(12, result.priority)
self.assertTrue(result.enabled)
self.assertEqual({}, result.data)
self.assertIsNone(result.last_op)
# do an update
cp.enabled = False
cp.priority = 60
cp.data = {'foo': 'bar'}
timestamp = timeutils.utcnow(True)
cp.last_op = timestamp
new_id = cp.store(self.context)
self.assertEqual(cp_id, new_id)
result = cpo.ClusterPolicy.get(self.context, CLUSTER_ID, POLICY_ID)
self.assertIsNotNone(result)
self.assertFalse(result.enabled)
self.assertEqual(60, result.priority)
self.assertEqual({'foo': 'bar'}, result.data)
self.assertEqual(common_utils.isotime(timestamp),
common_utils.isotime(result.last_op))
def test_to_dict(self):
profile = self._create_profile('test-profile')
# simulate a store()
profile.id = 'FAKE_ID'
expected = {
'id': 'FAKE_ID',
'name': profile.name,
'type': profile.type,
'user': profile.user,
'project': profile.project,
'domain': profile.domain,
'spec': profile.spec,
'metadata': profile.metadata,
'created_at': common_utils.isotime(profile.created_at),
'updated_at': None,
}
result = profile.to_dict()
self.assertEqual(expected, result)
def test_to_dict(self):
policy = self._create_policy('test-policy')
policy_id = policy.store(self.ctx)
self.assertIsNotNone(policy_id)
expected = {
'id': policy_id,
'name': policy.name,
'type': policy.type,
'user': policy.user,
'project': policy.project,
'domain': policy.domain,
'spec': policy.spec,
'data': policy.data,
'created_at': common_utils.isotime(policy.created_at),
'updated_at': None,
}
result = pb.Policy.load(self.ctx, policy_id=policy.id)
self.assertEqual(expected, result.to_dict())
def test_to_dict(self):
profile = self._create_profile('test-profile')
# simulate a store()
profile.id = 'FAKE_ID'
expected = {
'id': 'FAKE_ID',
'name': profile.name,
'type': profile.type,
'user': profile.user,
'project': profile.project,
'domain': profile.domain,
'spec': profile.spec,
'metadata': profile.metadata,
'created_at': common_utils.isotime(profile.created_at),
'updated_at': None,
}
result = profile.to_dict()
self.assertEqual(expected, result)
def test_action_to_dict(self, mock_dep_by, mock_dep_on):
mock_dep_on.return_value = ['ACTION_1']
mock_dep_by.return_value = ['ACTION_2']
action = ab.Action(OBJID, 'OBJECT_ACTION', self.ctx,
**self.action_values)
action.id = 'FAKE_ID'
ts = common_utils.isotime(self.action_values['created_at'])
expected = {
'id': 'FAKE_ID',
'name': 'FAKE_NAME',
'action': 'OBJECT_ACTION',
'target': OBJID,
'cause': 'FAKE_CAUSE',
'owner': OWNER_ID,
'interval': 60,
'start_time': 0,
'end_time': 0,
'timeout': 120,
'status': 'FAKE_STATUS',
'status_reason': 'FAKE_STATUS_REASON',
'inputs': {
'param': 'value'
},
'outputs': {
'key': 'output_value'
},
'depends_on': ['ACTION_1'],
'depended_by': ['ACTION_2'],
'created_at': ts,
'updated_at': None,
'data': {
'data_key': 'data_value'
},
'user': USER_ID,
'project': PROJECT_ID,
}
res = action.to_dict()
self.assertEqual(expected, res)
mock_dep_on.assert_called_once_with(action.context, 'FAKE_ID')
mock_dep_by.assert_called_once_with(action.context, 'FAKE_ID')
