def test_library_relocation(caplog):
testing_utils.initialize_environment_core(
libraries={"test_scripts": testing_utils.TEST_ASSETS_PATH})
interface.open_folder_func = open_folder
interface.show_notice_func = show_notice
state_machine = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"library_relocation_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_execution_engine.stop()
try:
assert state_machine.root_state.output_data["output_0"] == 27
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=1)
logger.info("State machine execution finished!")
def test_concurrency_barrier_save_load(caplog):
concurrency_barrier_state = create_concurrency_barrier_state()
state_machine = StateMachine(concurrency_barrier_state)
test_path = testing_utils.get_unique_temp_path()
storage.save_state_machine_to_path(state_machine, test_path)
sm_loaded = storage.load_state_machine_from_path(test_path)
root_state = sm_loaded.root_state
input_data = {"input_data_port1": 0.1, "input_data_port2": 0.1}
output_data = {"output_data_port1": None}
root_state.input_data = input_data
root_state.output_data = output_data
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
try:
assert rafcon.core.singleton.global_variable_manager.get_variable("var_x") == 10
assert rafcon.core.singleton.global_variable_manager.get_variable("var_y") == 20
assert root_state.final_outcome.outcome_id == 4
with pytest.raises(ValueError):
concurrency_barrier_state.remove(UNIQUE_DECIDER_STATE_ID)
with pytest.raises(AttributeError):
concurrency_barrier_state.remove_state(UNIQUE_DECIDER_STATE_ID)
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog, expected_warnings=0, expected_errors=1)
def test_runtime_checks_for_data_port_data_types(caplog):
storage_path = testing_utils.get_unique_temp_path()
print(storage_path)
sm = create_state_machine2()
# test output port type check
script_text = 'def execute(self, inputs, outputs, gvm):\n' \
' outputs["output_data_port1"] = [1, 2, 3]\n' \
' return 3'
sm.get_state_by_path('FirstLevel1/ZeroLevel2').script_text = script_text
# TODO comment (next 2 lines) in after final fix of tuple storing bug is applied and remove 3 line (4 storage check)
# storage.save_state_machine_to_path(sm, storage_path)
# sm_loaded = storage.load_state_machine_from_path(storage_path)
sm_loaded = sm
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
# 6 errors -> IN ORDER output port-, root state scoped-, input port-, output port-, root state scoped- and
# root state output port-data-type-errors
testing_utils.shutdown_environment_only_core(caplog=caplog, expected_errors=6)
def test_preemption_behaviour_during_stop(caplog):
testing_utils.initialize_environment_core()
path = testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"preemption_behaviour_during_stop"))
state_machine = storage.load_state_machine_from_path(path)
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
thread = threading.Thread(
target=trigger_stop,
args=[
state_machine, rafcon.core.singleton.state_machine_execution_engine
])
thread.start()
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
try:
assert global_variable_manager.get_variable("s1") == 1
assert global_variable_manager.get_variable("s2") == 1
assert not global_variable_manager.variable_exist("s3")
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_only_run_this_state(caplog):
# run_selected
# Initialize testing environment
testing_utils.initialize_environment_core()
# Load State Machine
sm = storage.load_state_machine_from_path(testing_utils.get_test_sm_path(os.path.join(
"unit_test_state_machines", "test_run_only_this_state")))
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
# Run only selected state machine
rafcon.core.singleton.global_variable_manager.set_variable("test_value", 0)
state_machine_execution_engine.run_only_selected_state("BSSKWR/YEKRMH/TZILCN", sm.state_machine_id)
sm.join()
assert rafcon.core.singleton.global_variable_manager.get_variable("test_value") == 1
# Test running a state inside a concurrency state
rafcon.core.singleton.global_variable_manager.set_variable("test_value_concurrency", 2)
state_machine_execution_engine.run_only_selected_state("BSSKWR/IQURCQ/LLRMSU/VYGYRO", sm.state_machine_id)
sm.join()
# assert variable state
try:
assert rafcon.core.singleton.global_variable_manager.get_variable("test_value_concurrency") == 1
# Shutdown testing environment
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_default_values_of_data_ports(caplog):
storage_path = testing_utils.get_unique_temp_path()
print(storage_path)
sm = create_state_machine()
storage.save_state_machine_to_path(sm, storage_path)
sm_loaded = storage.load_state_machine_from_path(storage_path)
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
print(root_state.output_data)
try:
assert root_state.output_data["output_data_port1"] == "default_value"
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_load_wrong_data_types(caplog):
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
rafcon.core.singleton.library_manager.initialize()
state_machine = get_test_state_machine("wrong_data_types")
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_execution_engine.stop()
try:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"x") == 1
# 4 data type errors -> 2 data flow port to port data type inequality and while runtime 1 input- and 1 output data type error
# 2 data type warnings -> 1 input- and 1 output-data port data type warnings while loading of state machine
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=2,
expected_errors=4)
logger.info("State machine execution finished!")
def test_error_propagation(caplog):
testing_utils.initialize_environment_core()
sm = state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"error_propagation_test")))
state_machine_manager.remove_state_machine(sm.state_machine_id)
try:
assert sm.root_state.output_data["error_check"] == "successfull"
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=1,
expected_errors=2)
def test_preemption_behaviour_in_preemption_state(caplog):
testing_utils.initialize_environment_core()
sm = state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"preemption_behaviour_test_sm")))
rafcon.core.singleton.state_machine_manager.remove_state_machine(
sm.state_machine_id)
from rafcon.core.singleton import global_variable_manager
try:
assert global_variable_manager.get_variable("s2") == 1.0
assert not global_variable_manager.variable_exist("s3")
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_last_wins_value_collection_for_data_ports(caplog):
sm_path = testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "last_data_wins_test"))
sm_loaded = storage.load_state_machine_from_path(sm_path)
root_state = sm_loaded.root_state
state_machine = StateMachine(root_state)
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(state_machine.state_machine_id)
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_load_not_existing_outcome(caplog):
testing_utils.test_multithreading_lock.acquire()
rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
rafcon.core.singleton.library_manager.initialize()
state_machine = get_test_state_machine("outcome_not_existing")
# state_machine = get_test_state_machine("correct_library_inclusion")
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=2)
logger.info("State machine execution finished!")
def test_custom_entry_point(caplog):
testing_utils.initialize_environment_core()
start_state_id = "RWUZOP/ZDWBKU/HADSLI"
sm = rafcon.core.singleton.state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"test_custom_entry_point")),
start_state_path=start_state_id)
rafcon.core.singleton.state_machine_manager.remove_state_machine(
sm.state_machine_id)
try:
assert not rafcon.core.singleton.global_variable_manager.variable_exist(
"start_id21")
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_error_propagation(caplog, recompile):
testing_utils.initialize_environment_core(
{"SCRIPT_RECOMPILATION_ON_STATE_EXECUTION": recompile})
sm = state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"error_propagation_test")))
state_machine_manager.remove_state_machine(sm.state_machine_id)
try:
assert sm.root_state.output_data["error_check"] == "successfull"
finally:
if recompile:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=2)
else:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=3)
def test_multi_events(caplog):
testing_utils.initialize_environment_core()
execution_trigger_thread = threading.Thread(
target=trigger_exectuion_engine,
args=[global_variable_manager, state_machine_execution_engine])
execution_trigger_thread.start()
sm = state_machine_execution_engine.execute_state_machine_from_path(
path=testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "multi_events_test")))
execution_trigger_thread.join()
state_machine_manager.remove_state_machine(sm.state_machine_id)
try:
assert global_variable_manager.get_variable("sm_status") == 2
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=0)
def test_execution_log_without_file_system(caplog):
try:
testing_utils.initialize_environment_core(
core_config={
'IN_MEMORY_EXECUTION_HISTORY_ENABLE':
True,
'FILE_SYSTEM_EXECUTION_HISTORY_ENABLE':
False,
'EXECUTION_LOG_PATH':
testing_utils.get_unique_temp_path() + '/test_execution_log'
})
state_machine = global_storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"execution_file_log_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
while not state_machine.root_state.final_outcome:
time.sleep(0.1)
rafcon.core.singleton.state_machine_execution_engine.join()
execution_history = state_machine.execution_histories[0]
assert len(execution_history) == 32
assert isinstance(execution_history[0], StateMachineStartItem)
assert isinstance(execution_history[1], CallItem)
assert isinstance(execution_history[2], CallItem)
assert isinstance(execution_history[3], ReturnItem)
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
except ImportError: # if pandas is not installed
print("test_execution_log skipped as pandas is not installed")
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=0)
def test_execution_log(caplog):
testing_utils.initialize_environment_core(
core_config={
'IN_MEMORY_EXECUTION_HISTORY_ENABLE':
False,
'FILE_SYSTEM_EXECUTION_HISTORY_ENABLE':
False,
'EXECUTION_LOG_PATH':
testing_utils.get_unique_temp_path() + '/test_execution_log'
})
# this state machine features:
# * hierarchies
# * barrier concurrency
# * execution states
# * data flows
# * logic flows
state_machine = global_storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"execution_file_log_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
while not state_machine.root_state.final_outcome:
time.sleep(0.1)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
# the test assertions are that there are no errors/warnings
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=0)
def test_load_data_ports_not_existing(caplog):
testing_utils.test_multithreading_lock.acquire()
state_machine = get_test_state_machine("data_ports_not_existing")
# state_machine = get_test_state_machine("correct_library_inclusion")
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
rafcon.core.singleton.state_machine_execution_engine.stop()
try:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"x") == 1
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=2,
expected_errors=0)
logger.info("State machine execution finished!")
def test_run_this_state(caplog):
# run_selected
# Initialize testing environment
testing_utils.initialize_environment_core()
# Load State Machine
sm = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "test_run_this_state")))
rafcon.core.singleton.state_machine_manager.add_state_machine(sm)
# Run selected state machine
rafcon.core.singleton.global_variable_manager.set_variable("test_value", 1)
state_machine_execution_engine.run_selected_state("BTWFZQ/EPQSTG",
sm.state_machine_id)
wait_for_execution_engine_sync_counter(1, logger)
state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
# assert variable state
try:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"test_value") == 2
# Shutdown testing environment
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_execute_script_returns_none(caplog):
testing_utils.initialize_environment_core()
state_machine_path = testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "return_none_test_sm"))
state_machine = storage.load_state_machine_from_path(state_machine_path)
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
assert state_machine.file_system_path == state_machine_path
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
try:
assert state_machine.root_state.final_outcome.outcome_id == 0
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=1)
def teardown_class(cls):
cls.state_machine = None
testing_utils.shutdown_environment_only_core()
def test_step_through_library(caplog):
testing_utils.initialize_environment_core()
testing_utils.rewind_and_set_libraries({
"unit_test_state_machines":
os.path.join(testing_utils.TEST_ASSETS_PATH,
"unit_test_state_machines")
})
state_machine = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"stepping_test_with_library")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
rafcon.core.singleton.state_machine_execution_engine.step_mode(
state_machine.state_machine_id)
wait_for_execution_engine_sync_counter(1, logger)
# step till library
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step into library and step out
rafcon.core.singleton.state_machine_execution_engine.step_into()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_out()
wait_for_execution_engine_sync_counter(1, logger)
# step till library
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step into library and step over library children
rafcon.core.singleton.state_machine_execution_engine.step_into()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
# step over last library item
rafcon.core.singleton.state_machine_execution_engine.step_over()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
try:
from rafcon.core.state_elements.scope import ScopedVariable
for s in state_machine.root_state.scoped_data.values():
if s.name == 'bottles' and s.data_port_type == ScopedVariable:
assert s.value == 4
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_step_into_over_out_no_library(caplog):
testing_utils.initialize_environment_core()
state_machine = storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines", "stepping_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
with state_machine_execution_engine._status.execution_condition_variable:
state_machine_execution_engine.synchronization_counter = 0
rafcon.core.singleton.state_machine_execution_engine.step_mode(
state_machine.state_machine_id)
wait_for_execution_engine_sync_counter(1, logger)
# sm structure
# GLSUJY
# GLSUJY/PXTKIH
# GLSUJY/NDIVLD
# GLSUJY/SFZGMH
# GLSUJY/SMCOIB
# GLSUJY/SMCOIB/YSBJGK
# GLSUJY/SMCOIB/OUWQUJ
# GLSUJY/SMCOIB/UGGFFI
execute_command_synchronized_on_state(state_machine, "GLSUJY/PXTKIH",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/NDIVLD",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/SFZGMH",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/SMCOIB",
"step_over", 1)
execute_command_synchronized_on_state(state_machine, "GLSUJY/PXTKIH",
"step_into")
execute_command_synchronized_on_state(state_machine, "GLSUJY/NDIVLD",
"step_into")
execute_command_synchronized_on_state(state_machine, "GLSUJY/SFZGMH",
"step_into")
execute_command_synchronized_on_state(state_machine,
"GLSUJY/SMCOIB",
"step_into",
join=False)
execute_command_synchronized_on_state(state_machine,
"GLSUJY/SMCOIB/YSBJGK", "step_into")
rafcon.core.singleton.state_machine_execution_engine.step_out()
wait_for_execution_engine_sync_counter(1, logger)
rafcon.core.singleton.state_machine_execution_engine.stop()
rafcon.core.singleton.state_machine_execution_engine.join()
try:
assert rafcon.core.singleton.global_variable_manager.get_variable(
"bottles") == 95
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog)
def test_execution_log(caplog):
try:
testing_utils.initialize_environment_core(
core_config={
'IN_MEMORY_EXECUTION_HISTORY_ENABLE':
True,
'FILE_SYSTEM_EXECUTION_HISTORY_ENABLE':
True,
'EXECUTION_LOG_PATH':
testing_utils.get_unique_temp_path() + '/test_execution_log'
})
state_machine = global_storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"execution_file_log_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
while not state_machine.root_state.final_outcome:
time.sleep(0.1)
rafcon.core.singleton.state_machine_execution_engine.join()
import shelve
import json
ss = shelve.open(state_machine.get_last_execution_log_filename())
target_dict = {} # can be used for debugging
for key, value in ss.items():
# print(value)
target_dict[int(key[-3:].lstrip("0"))] = value
assert len(ss) == 36
start, next, concurrent, hierarchy, collapsed_items = log_helper.log_to_collapsed_structure(
ss)
prod1_id = [
k for k, v in collapsed_items.items()
if v['state_name'] == 'MakeProd1'
][0]
prod1 = collapsed_items[prod1_id]
assert prod1['scoped_data_ins']['product'] == 2
assert prod1['scoped_data_outs']['product'] == 2
assert prod1['outcome_name'] == 'success'
assert prod1['semantic_data']['test_key'] == 'TestValue'
prod2_id = [
k for k, v in collapsed_items.items()
if v['state_name'] == 'MakeProd2'
][0]
prod2 = collapsed_items[prod2_id]
assert prod2['data_ins']['input_1'] == 0
assert prod2['data_outs']['output_1'] == 3
assert prod2['scoped_data_ins']['product'] == 1
assert prod2['scoped_data_outs']['product'] == 1
start_states = [
k for k, v in collapsed_items.items() if v['state_name'] == 'Start'
and v['state_type'] == 'ExecutionState'
]
assert len(
start_states
) == 3 # Start state is executed three times until state machine is done
start_id = start_states[0]
start_item = collapsed_items[start_id]
assert 'Starts the factory' in start_item['description']
df = log_helper.log_to_DataFrame(ss)
all_starts = df.groupby('state_name').get_group('Start')
assert len(all_starts) == 3
assert list(
all_starts['outcome_name']) == ['success', 'success', 'done']
execution_history = state_machine.execution_histories[0]
assert len(execution_history) == 32
assert isinstance(execution_history[0], StateMachineStartItem)
assert isinstance(execution_history[1], CallItem)
assert isinstance(execution_history[2], CallItem)
assert isinstance(execution_history[3], ReturnItem)
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
except ImportError: # if pandas is not installed
print("test_execution_log skipped as pandas is not installed")
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=0)
def test_execution_log(caplog):
try:
testing_utils.initialize_environment_core(
core_config={
'EXECUTION_LOG_ENABLE':
True,
'EXECUTION_LOG_PATH':
testing_utils.get_unique_temp_path() + '/test_execution_log'
})
state_machine = global_storage.load_state_machine_from_path(
testing_utils.get_test_sm_path(
os.path.join("unit_test_state_machines",
"execution_file_log_test")))
rafcon.core.singleton.state_machine_manager.add_state_machine(
state_machine)
rafcon.core.singleton.state_machine_execution_engine.start(
state_machine.state_machine_id)
rafcon.core.singleton.state_machine_execution_engine.join()
import shelve
import json
ss = shelve.open(state_machine.get_last_execution_log_filename())
assert len(ss) == 36
start, next, concurrent, hierarchy, collapsed_items = log_helper.log_to_collapsed_structure(
ss)
prod1_id = [
k for k, v in collapsed_items.items()
if v['state_name'] == 'MakeProd1'
][0]
prod1 = collapsed_items[prod1_id]
assert prod1['scoped_data_ins']['product'] == 2
assert prod1['scoped_data_outs']['product'] == 2
assert prod1['outcome_name'] == 'success'
assert prod1['semantic_data']['test_key'] == 'TestValue'
prod2_id = [
k for k, v in collapsed_items.items()
if v['state_name'] == 'MakeProd2'
][0]
prod2 = collapsed_items[prod2_id]
assert prod2['data_ins']['input_1'] == 0
assert prod2['data_outs']['output_1'] == 3
assert prod2['scoped_data_ins']['product'] == 1
assert prod2['scoped_data_outs']['product'] == 1
start_states = [
k for k, v in collapsed_items.items() if v['state_name'] == 'Start'
and v['state_type'] == 'ExecutionState'
]
assert len(
start_states
) == 3 # Start state is executed three times until state machine is done
start_id = start_states[0]
start_item = collapsed_items[start_id]
assert 'Starts the factory' in start_item['description']
df = log_helper.log_to_DataFrame(ss)
all_starts = df.groupby('state_name').get_group('Start')
assert len(all_starts) == 3
assert list(
all_starts['outcome_name']) == ['success', 'success', 'done']
rafcon.core.singleton.state_machine_manager.remove_state_machine(
state_machine.state_machine_id)
except ImportError: # if pandas is not installed
pass
finally:
testing_utils.shutdown_environment_only_core(caplog=caplog,
expected_warnings=0,
expected_errors=0)
