def test_minion_perform_execute_reload_code_success():
workflow_id = '6666'
app_id = '667788'
job_id = '1'
workflow = {
'workflow_id': workflow_id,
'app_id': app_id,
'job_id': job_id,
'type': 'execute',
'workflow': ''
}
function_name = 'juicer.spark.transpiler.SparkTranspiler.transpile'
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
with mock.patch(function_name) as mocked_transpile:
with mock.patch('juicer.workflow.workflow.Workflow'
'._build_initial_workflow_graph') as mocked_fn:
mocked_fn.side_effect = lambda: ""
# Setup for mocked_transpile
mocked_transpile.side_effect = get_side_effect(None, None, 2)
redis_conn = mocked_redis()
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion.get_or_create_spark_session = \
dummy_get_or_create_spark_session
minion._emit_event = dummy_emit_event
# Configure mocked redis
state_control = StateControlRedis(redis_conn)
with open(
os.path.join(os.path.dirname(__file__),
'fixtures/simple_workflow.json')) as f:
data = json.loads(f.read())
workflow['workflow'] = data
state_control.push_app_queue(app_id, json.dumps(workflow))
minion._process_message()
assert minion._state == {'res': 'version 1.0'}, 'Invalid state'
# Executes the same workflow, but code should be different
state_control.push_app_queue(app_id, json.dumps(workflow))
assert state_control.get_app_output_queue_size(
app_id) == 1, 'Wrong number of output messages'
state_control.pop_app_queue(app_id, True, 0)
minion.transpiler.transpile = get_side_effect(None, None, 3)
minion._process_message()
assert minion._state == {'res': 'version 2.1'}, 'Invalid state'
assert state_control.get_app_output_queue_size(
app_id) == 2, 'Wrong number of output messages'
def test_minion_generate_output_success():
workflow_id = 6666
app_id = 897987
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
redis_conn = mocked_redis()
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion._emit_event = dummy_emit_event
state_control = StateControlRedis(redis_conn)
msgs = ["Message being sent \n{}", {'msg': 'Dictionary being sent'}]
for msg in msgs:
minion._generate_output(msg)
result = json.loads(
state_control.pop_app_output_queue(app_id, False))
assert sorted(result.keys()) == sorted(
['date', 'status', 'message', 'workflow_id', 'app_id', 'code'])
assert result['app_id'] == app_id
assert result['message'] == msg
assert state_control.get_app_output_queue_size(app_id) == 0
def test_minion_perform_execute_success():
workflow_id = '6666'
app_id = '897447'
job_id = '1'
function_name = 'juicer.spark.transpiler.SparkTranspiler.transpile'
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
with mock.patch(function_name) as mocked_transpile:
# Setup for mocked_transpile
mocked_transpile.side_effect = get_side_effect(None, 0, 1)
redis_conn = mocked_redis()
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion.get_or_create_spark_session = \
dummy_get_or_create_spark_session
minion._emit_event = dummy_emit_event
# Configure mocked redis
state_control = StateControlRedis(redis_conn)
with open(
os.path.join(os.path.dirname(__file__),
'fixtures/simple_workflow.json')) as f:
data = json.loads(f.read())
msg = {
'workflow_id': workflow_id,
'app_id': app_id,
'job_id': job_id,
'type': 'execute',
'workflow': data
}
state_control.push_app_queue(app_id, json.dumps(msg))
minion._process_message()
assert minion._state == {
"xyz-647": {
'port0': {
'output': "df",
'sample': []
},
'time': 27.27
}
}, 'Invalid state'
assert state_control.get_app_output_queue_size(
app_id) == 1, 'Wrong number of output messages'
def test_minion_generate_invalid_code_failure():
workflow_id = '6666'
app_id = '667788'
job_id = '1'
workflow = {
'workflow_id': workflow_id,
'app_id': app_id,
'job_id': job_id,
'type': 'execute',
'workflow': ''
}
function_name = 'juicer.spark.transpiler.SparkTranspiler.transpile'
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
with mock.patch(function_name) as mocked_transpile:
with mock.patch('juicer.workflow.workflow.Workflow'
'._build_initial_workflow_graph') as mocked_fn:
mocked_fn.side_effect = lambda: ""
# Setup for mocked_transpile
mocked_transpile.side_effect = get_side_effect(None, None, 4)
redis_conn = mocked_redis()
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion._emit_event = dummy_emit_event
# Configure mocked redis
with open(
os.path.join(os.path.dirname(__file__),
'fixtures/simple_workflow.json')) as f:
data = json.loads(f.read())
workflow['workflow'] = data
state_control = StateControlRedis(redis_conn)
state_control.push_app_queue(app_id, json.dumps(workflow))
minion._process_message()
assert state_control.get_app_output_queue_size(
app_id) == 2, 'Wrong number of output messages'
# Discards
state_control.pop_app_output_queue(app_id)
msg = json.loads(state_control.pop_app_output_queue(app_id))
assert msg['status'] == 'ERROR'
assert msg['message'][:19] == 'Invalid Python code'
def test_minion_ping_success():
workflow_id = 6666
app_id = 897987
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
redis_conn = mocked_redis()
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion._emit_event = dummy_emit_event
minion._perform_ping()
state_control = StateControlRedis(redis_conn)
assert json.loads(state_control.get_minion_status(app_id)) == {
'status': 'READY',
'pid': os.getpid()
}
assert state_control.get_app_output_queue_size(app_id) == 0
def test_minion_perform_deliver_missing_state_process_app_with_failure():
workflow_id = '6666'
app_id = '6000'
job_id = '1'
out_queue = 'queue_2000'
task_id = '033f-284ab-28987e'
function_name = 'juicer.spark.transpiler.SparkTranspiler.transpile'
with mock.patch('redis.StrictRedis',
mock_strict_redis_client) as mocked_redis:
with mock.patch(function_name) as mocked_transpile:
with mock.patch('juicer.workflow.workflow.Workflow'
'._build_initial_workflow_graph') as mocked_fn:
mocked_fn.side_effect = lambda: ""
# Setup for mocked_transpile
# Invalid code
mocked_transpile.side_effect = get_side_effect(
get_records(), task_id, 4)
redis_conn = mocked_redis()
state_control = StateControlRedis(redis_conn)
data = {
'workflow_id': workflow_id,
'app_id': app_id,
'job_id': job_id,
'type': 'deliver',
'task_id': task_id,
'port': 'port0',
'output': out_queue,
'workflow': {
"tasks": [],
"flows": []
}
}
state_control.push_app_queue(app_id, json.dumps(data))
minion = SparkMinion(redis_conn=redis_conn,
workflow_id=workflow_id,
app_id=app_id,
config=config)
minion._emit_event = dummy_emit_event
minion._state = {}
minion._process_message()
# Discard first status message
state_control.pop_app_output_queue(app_id, False)
# First message is about missing state
msg = json.loads(
state_control.pop_app_output_queue(app_id, False))
assert msg['status'] == 'WARNING', 'Invalid status'
assert msg['code'] == minion.MNN003[0], 'Invalid code'
# Second message is about invalid Python code
msg = json.loads(
state_control.pop_app_output_queue(app_id, False))
assert msg['status'] == 'ERROR', 'Invalid status'
assert msg.get('code') == minion.MNN006[0], 'Invalid code'
# Third message is about unable to read data
msg = json.loads(
state_control.pop_app_output_queue(app_id, False))
assert msg['status'] == 'ERROR', 'Invalid status'
assert msg.get('code') == minion.MNN005[0], 'Invalid code'
assert state_control.get_app_output_queue_size(
app_id) == 0, 'There are messages in app output queue!'
result = json.loads(state_control.pop_queue(out_queue, False))
assert not result['sample'], 'Wrong CSV generated'
