def test_node_does_not_exist(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.has_node = MagicMock(return_value=False)
data = taskflow.get_node_data(node_id="node_id", username="******")
self.assertFalse(data["result"])
self.assertEqual(data["code"], err_code.REQUEST_PARAM_INVALID.code)
def test_node_does_not_exist(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.has_node = MagicMock(return_value=False)
detail = taskflow.spec_nodes_timer_reset(node_id="node_id",
username="******",
inputs="inputs")
self.assertFalse(detail["result"])
self.assertEqual(detail["code"], err_code.REQUEST_PARAM_INVALID.code)
def test_success(self):
taskflow = TaskFlowInstance()
taskflow.pk = 1
old_pipeline = PipelineInstance()
taskflow.pipeline_instance = old_pipeline
taskflow.pipeline_instance.clone = MagicMock(
return_value=PipelineInstance())
username = "******"
with patch(TASKINSTANCE_SAVE, MagicMock()):
task = taskflow.clone(username)
self.assertIsNone(task.id)
self.assertFalse(task.is_deleted)
taskflow.save.assert_called_once()
old_pipeline.clone.assert_called_once_with(username)
def test_callback(self):
instance = TaskFlowInstance()
objects_callback_return = {'result': True, 'message': 'success'}
with mock.patch(TASKINSTANCE_OBJECTS_CALLBACK, MagicMock(return_value=objects_callback_return)):
with mock.patch(TASKINSTANCE_HAS_NODE, MagicMock(return_value=False)):
result = instance.callback('act_id', 'data')
self.assertFalse(result['result'])
self.assertTrue('message' in result)
TaskFlowInstance.objects.callback.assert_not_called()
with mock.patch(TASKINSTANCE_HAS_NODE, MagicMock(return_value=True)):
result = instance.callback('act_id', 'data')
self.assertTrue(result['result'])
self.assertTrue('message' in result)
TaskFlowInstance.objects.callback.assert_called_once_with('act_id', 'data')
def test_success(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
dispatch_return = {"result": True, "data": {"data": "data"}}
dispatcher.dispatch = MagicMock(return_value=dispatch_return)
dispatcher_init = MagicMock(return_value=dispatcher)
node_id = "node_id"
username = "******"
inputs = "inputs"
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER, dispatcher_init):
detail = taskflow.spec_nodes_timer_reset(node_id=node_id,
username=username,
inputs=inputs)
dispatcher_init.assert_called_once_with(engine_ver=taskflow.engine_ver,
node_id=node_id,
taskflow_id=1)
dispatcher.dispatch.assert_has_calls([
call(command="forced_fail", operator=username),
call(command="retry", operator=username, inputs="inputs")
])
self.assertEqual(detail, dispatch_return)
def test_raise(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
dispatcher.dispatch = MagicMock(side_effect=Exception("exception"))
dispatcher_init = MagicMock(return_value=dispatcher)
action = "action"
node_id = "node_id"
username = "******"
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER, dispatcher_init):
result = taskflow.nodes_action(action=action,
node_id=node_id,
username=username)
dispatcher_init.assert_called_once_with(engine_ver=taskflow.engine_ver,
node_id=node_id,
taskflow_id=1)
dispatcher.dispatch.assert_called_once_with(action, username)
self.assertEqual(
result,
{
"result": False,
"message":
"task[id=1] node[id=node_id] action failed: exception",
"code": err_code.UNKNOWN_ERROR.code,
},
)
def test_success(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
get_node_data_return = {"result": True, "data": {"data": "data"}}
get_node_detail_return = {"result": True, "data": {"detail": "detail"}}
dispatcher.get_node_data = MagicMock(return_value=get_node_data_return)
dispatcher.get_node_detail = MagicMock(
return_value=get_node_detail_return)
dispatcher_init = MagicMock(return_value=dispatcher)
node_id = "node_id"
username = "******"
component_code = "component_code"
subprocess_stack = ["1"]
loop = 1
include_data = True
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER, dispatcher_init):
detail = taskflow.get_node_detail(
node_id=node_id,
username=username,
component_code=component_code,
subprocess_stack=subprocess_stack,
loop=loop,
include_data=include_data,
project_id="project_id",
)
dispatcher_init.assert_called_once_with(engine_ver=taskflow.engine_ver,
node_id=node_id,
taskflow_id=1)
dispatcher.get_node_data.assert_called_once_with(
username=username,
component_code=component_code,
subprocess_stack=subprocess_stack,
pipeline_instance=taskflow.pipeline_instance,
loop=loop,
project_id="project_id",
)
dispatcher.get_node_detail.assert_called_once_with(
username=username,
component_code=component_code,
subprocess_stack=subprocess_stack,
pipeline_instance=taskflow.pipeline_instance,
loop=loop,
)
self.assertEqual(
detail, {
"code": 0,
"data": {
"data": "data",
"detail": "detail"
},
"message": "",
"result": True
})
def test_get_task_status__is_subprocess(self):
task = MockTaskFlowInstance(
get_status_raise=TaskFlowInstance.DoesNotExist())
with mock.patch(TASKINSTANCE_GET, MagicMock(return_value=task)):
response = self.client.get(path=self.GET_TASK_STATUS_URL.format(
task_id=TEST_TASKFLOW_ID, bk_biz_id=TEST_BIZ_CC_ID))
TaskFlowInstance.format_pipeline_status.assert_called_once_with(
TEST_DATA)
data = json.loads(response.content)
self.assertTrue(data['result'])
self.assertEqual(data['data'], TEST_DATA)
def start_task(request, task_id, project_id):
username = request.user.username
project = request.project
if env.TASK_OPERATION_THROTTLE and not check_task_operation_throttle(
project.id, "start"):
return {
"result":
False,
"message":
"project id: {} reach the limit of starting tasks".format(
project.id),
"code":
err_code.INVALID_OPERATION.code,
}
if TaskFlowInstance.objects.is_task_started(project_id=project.id,
id=task_id):
return {
"result": False,
"code": err_code.INVALID_OPERATION.code,
"message": "task already started"
}
queue, routing_key = PrepareAndStartTaskQueueResolver(
settings.API_TASK_QUEUE_NAME_V2).resolve_task_queue_and_routing_key()
prepare_and_start_task.apply_async(kwargs=dict(task_id=task_id,
project_id=project.id,
username=username),
queue=queue,
routing_key=routing_key)
task_url = TaskFlowInstance.task_url(project_id=project.id,
task_id=task_id)
return {
"task_url": task_url,
"data": {
"task_url": task_url
},
"result": True,
"code": err_code.SUCCESS.code,
}
def test_template_source_is_not_project(self):
task_template = MagicMock()
task_template.objects.filter = MagicMock()
with patch(TASKFLOW_MODEL_TASK_TEMPLATE, task_template):
taskflow = TaskFlowInstance()
taskflow.template_source = "common"
self.assertEqual(taskflow.executor_proxy, None)
task_template.objects.filter.assert_not_called()
taskflow = TaskFlowInstance()
taskflow.template_source = "onetime"
self.assertEqual(taskflow.executor_proxy, None)
task_template.objects.filter.assert_not_called()
def test_get_node_data_err(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
get_node_data_return = {"result": False}
dispatcher.get_node_data = MagicMock(return_value=get_node_data_return)
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER,
MagicMock(return_value=dispatcher)):
detail = taskflow.get_node_detail(node_id="node_id",
username="******",
project_id="project_id")
self.assertEqual(detail, get_node_data_return)
def test_normal(self):
task_template = MagicMock()
values_list_return = MagicMock()
values_list_return.first = MagicMock(return_value="dummy")
_filter_return = MagicMock()
_filter_return.values_list = MagicMock(return_value=values_list_return)
_filter = MagicMock(return_value=_filter_return)
task_template.objects.filter = _filter
with patch(TASKFLOW_MODEL_TASK_TEMPLATE, task_template):
taskflow = TaskFlowInstance()
taskflow.template_source = "project"
self.assertEqual(taskflow.executor_proxy, "dummy")
taskflow = TaskFlowInstance()
taskflow.template_source = "business"
self.assertEqual(taskflow.executor_proxy, "dummy")
class NodeCallbackAPITest(APITest):
def url(self):
return "/apigw/node_callback/{task_id}/{project_id}/"
@mock.patch(
PROJECT_GET,
MagicMock(
return_value=MockProject(
project_id=TEST_PROJECT_ID, name=TEST_PROJECT_NAME, bk_biz_id=TEST_BIZ_CC_ID, from_cmdb=True,
)
),
)
def test_node_callback__success(self):
mock_instance = MockTaskFlowInstance()
with mock.patch(TASKINSTANCE_GET, MagicMock(return_value=mock_instance)):
response = self.client.post(
path=self.url().format(task_id=TEST_TASKFLOW_ID, project_id=TEST_PROJECT_ID),
data=json.dumps({"node_id": TEST_NODE_ID, "callback_data": TEST_CALLBACK_DATA}),
content_type="application/json",
)
data = json.loads(response.content)
self.assertTrue(data["result"], msg=data)
mock_instance.callback.assert_called_once_with(TEST_NODE_ID, TEST_CALLBACK_DATA, None)
@mock.patch(TASKINSTANCE_GET, MagicMock(side_effect=TaskFlowInstance.DoesNotExist()))
def test_node_callback__taskflow_does_not_exists(self):
response = self.client.post(
path=self.url().format(task_id=TEST_TASKFLOW_ID, project_id=TEST_PROJECT_ID),
data=json.dumps({"node_id": TEST_NODE_ID, "callback_data": TEST_CALLBACK_DATA}),
content_type="application/json",
)
data = json.loads(response.content)
self.assertFalse(data["result"])
self.assertTrue("message" in data)
def test_get_task_status__is_subprocess_raise(self):
task = MockTaskFlowInstance(
get_status_raise=TaskFlowInstance.DoesNotExist())
with mock.patch(TASKINSTANCE_GET, MagicMock(return_value=task)):
with mock.patch(APIGW_VIEW_PIPELINE_API_GET_STATUS_TREE,
MagicMock(side_effect=Exception())):
response = self.client.get(
path=self.GET_TASK_STATUS_URL.format(
task_id=TEST_TASKFLOW_ID, bk_biz_id=TEST_BIZ_CC_ID))
data = json.loads(response.content)
self.assertFalse(data['result'])
self.assertTrue('message' in data)
with mock.patch(TASKINSTANCE_FORMAT_STATUS,
MagicMock(side_effect=Exception())):
response = self.client.get(
path=self.GET_TASK_STATUS_URL.format(
task_id=TEST_TASKFLOW_ID, bk_biz_id=TEST_BIZ_CC_ID))
data = json.loads(response.content)
self.assertFalse(data['result'])
self.assertTrue('message' in data)
class GetTaskDetailAPITest(APITest):
def url(self):
return "/apigw/get_task_detail/{task_id}/{project_id}/"
@mock.patch(
PROJECT_GET,
MagicMock(return_value=MockProject(
project_id=TEST_PROJECT_ID,
name=TEST_PROJECT_NAME,
bk_biz_id=TEST_BIZ_CC_ID,
from_cmdb=True,
)),
)
def test_get_task_detail__success(self):
mock_taskflow = MockTaskFlowInstance(get_task_detail_return=TEST_DATA)
with mock.patch(TASKINSTANCE_GET,
MagicMock(return_value=mock_taskflow)):
assert_data = TEST_DATA
response = self.client.get(path=self.url().format(
task_id=TEST_TASKFLOW_ID, project_id=TEST_PROJECT_ID))
data = json.loads(response.content)
self.assertTrue(data["result"], msg=data)
self.assertEqual(data["data"], assert_data)
@mock.patch(TASKINSTANCE_GET,
MagicMock(side_effect=TaskFlowInstance.DoesNotExist()))
def test_get_task_detail__success__taskflow_does_not_exists(self):
response = self.client.get(path=self.url().format(
task_id=TEST_TASKFLOW_ID, project_id=TEST_PROJECT_ID))
data = json.loads(response.content)
self.assertFalse(data["result"])
self.assertTrue("message" in data)
def test_success(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
dispatch_return = {"result": True, "data": {"data": "data"}}
dispatcher.dispatch = MagicMock(return_value=dispatch_return)
dispatcher_init = MagicMock(return_value=dispatcher)
node_id = "node_id"
data = "data"
version = "version"
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER, dispatcher_init):
result = taskflow.callback(node_id=node_id, data=data, version=version)
dispatcher_init.assert_called_once_with(engine_ver=taskflow.engine_ver, node_id=node_id, taskflow_id=1)
dispatcher.dispatch.assert_called_once_with(command="callback", operator="", data=data, version=version)
self.assertEqual(result, dispatch_return)
def test_success(self):
taskflow = TaskFlowInstance()
taskflow.id = 1
taskflow.engine_ver = 2
taskflow.has_node = MagicMock(return_value=True)
dispatcher = MagicMock()
dispatch_return = {"result": True, "data": {"data": "data"}}
dispatcher.dispatch = MagicMock(return_value=dispatch_return)
dispatcher_init = MagicMock(return_value=dispatcher)
action = "action"
node_id = "node_id"
username = "******"
with patch(TASKFLOW_MODEL_NODE_CMD_DISPATCHER, dispatcher_init):
result = taskflow.nodes_action(action=action,
node_id=node_id,
username=username)
dispatcher_init.assert_called_once_with(engine_ver=taskflow.engine_ver,
node_id=node_id,
taskflow_id=1)
dispatcher.dispatch.assert_called_once_with(action, username)
self.assertEqual(result, dispatch_return)
def _new_taskflow(self):
taskflow = TaskFlowInstance()
setattr(taskflow, "pipeline_instance", MagicMock())
return taskflow
def test_not_common_func(self):
taskflow = TaskFlowInstance()
taskflow.flow_type = "common"
self.assertEqual(taskflow.function_task_claimant, None)
class GetTaskNodeDetailAPITest(APITest):
def url(self):
return "/apigw/get_task_node_detail/{task_id}/{project_id}/"
@mock.patch(
PROJECT_GET,
MagicMock(return_value=MockProject(
project_id=TEST_PROJECT_ID,
name=TEST_PROJECT_NAME,
bk_biz_id=TEST_BIZ_CC_ID,
from_cmdb=True,
)),
)
def test_get_task_node_detail__success(self):
mock_taskflow = MockTaskFlowInstance(get_node_detail_return={
"result": True,
"data": TEST_DATA
})
with mock.patch(TASKINSTANCE_GET,
MagicMock(return_value=mock_taskflow)):
assert_data = TEST_DATA
response = self.client.get(
path=self.url().format(task_id=TEST_TASKFLOW_ID,
project_id=TEST_PROJECT_ID),
data={
"node_id": TEST_NODE_ID,
"component_code": TEST_COMPONENT_CODE,
"subprocess_stack": TEST_SUBPROCESS_STACK,
},
)
data = json.loads(response.content)
self.assertTrue(data["result"], msg=data)
self.assertEqual(data["data"], assert_data)
mock_taskflow.get_node_detail.assert_called_once_with(
component_code="component_code",
node_id="node_id",
project_id="123",
subprocess_stack=[1, 2, 3],
username="",
)
@mock.patch(TASKINSTANCE_GET,
MagicMock(side_effect=TaskFlowInstance.DoesNotExist()))
def test_get_task_node_detail__taskflow_doest_not_exist(self):
response = self.client.get(
path=self.url().format(task_id=TEST_TASKFLOW_ID,
project_id=TEST_PROJECT_ID),
data={
"node_id": TEST_NODE_ID,
"component_code": TEST_COMPONENT_CODE,
"subprocess_stack": TEST_SUBPROCESS_STACK,
},
)
data = json.loads(response.content)
self.assertFalse(data["result"])
self.assertTrue("message" in data)
def test_get_task_node_detail__with_invalid_subprocess_stack(self):
response = self.client.get(
path=self.url().format(task_id=TEST_TASKFLOW_ID,
project_id=TEST_PROJECT_ID),
data={
"node_id": TEST_NODE_ID,
"component_code": TEST_COMPONENT_CODE,
"subprocess_stack": "abcdefg"
},
)
data = json.loads(response.content)
self.assertFalse(data["result"])
self.assertTrue("message" in data)
