def test_relocate_library(caplog): testing_utils.initialize_environment(gui_already_started=False, libraries={ "tutorials": testing_utils.TUTORIAL_PATH, }) try: from rafcon.gui.helpers.state_machine import relocate_library assert os.path.exists(LIBRARY_OS_PATH) assert not os.path.exists(NEW_LIBRARY_OS_PATH) state_machine = storage.load_state_machine_from_path( STATE_MACHINE_OS_PATH) library = list(state_machine.root_state.states.values())[0] assert library.library_path == LIBRARY_PATH assert library.library_name == LIBRARY_NAME relocate_library(LIBRARY_OS_PATH, LIBRARY_PATH, LIBRARY_NAME, NEW_DIRECTORY) assert not os.path.exists(LIBRARY_OS_PATH) assert os.path.exists(NEW_LIBRARY_OS_PATH) state_machine = storage.load_state_machine_from_path( STATE_MACHINE_OS_PATH) library = list(state_machine.root_state.states.values())[0] assert library.library_path == NEW_LIBRARY_PATH assert library.library_name == LIBRARY_NAME relocate_library(NEW_LIBRARY_OS_PATH, NEW_LIBRARY_PATH, LIBRARY_NAME, testing_utils.TUTORIAL_PATH) assert os.path.exists(LIBRARY_OS_PATH) assert not os.path.exists(NEW_LIBRARY_OS_PATH) state_machine = storage.load_state_machine_from_path( STATE_MACHINE_OS_PATH) library = list(state_machine.root_state.states.values())[0] assert library.library_path == LIBRARY_PATH assert library.library_name == LIBRARY_NAME finally: testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def test_hierarchy_save_load_test(caplog): storage_path = testing_utils.get_unique_temp_path() hierarchy_state = create_hierarchy_state() sm = StateMachine(hierarchy_state) storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) state_machine = StateMachine(sm_loaded.root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id rafcon.core.singleton.state_machine_execution_engine.start() rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) try: assert state_machine.root_state.output_data["output1"] == 52.0 # 2 type error -> one child output port data type error and root state scoped data type error testing_utils.assert_logger_warnings_and_errors(caplog, expected_errors=2) finally: testing_utils.test_multithreading_lock.release()
def get_library_state_copy_instance(self, lib_os_path): """ A method to get a state copy of the library specified via the lib_os_path. :param lib_os_path: the location of the library to get a copy for :return: """ # originally libraries were called like this; DO NOT DELETE; interesting for performance tests # state_machine = storage.load_state_machine_from_path(lib_os_path) # return state_machine.version, state_machine.root_state # TODO observe changes on file system and update data if lib_os_path in self._loaded_libraries: # this list can also be taken to open library state machines TODO -> implement it -> because faster state_machine = self._loaded_libraries[lib_os_path] # logger.info("Take copy of {0}".format(lib_os_path)) # as long as the a library state root state is never edited so the state first has to be copied here state_copy = copy.deepcopy(state_machine.root_state) return state_machine.version, state_copy else: state_machine = storage.load_state_machine_from_path(lib_os_path) self._loaded_libraries[lib_os_path] = state_machine if config.global_config.get_config_value( "NO_PROGRAMMATIC_CHANGE_OF_LIBRARY_STATES_PERFORMED", False): return state_machine.version, state_machine.root_state else: state_copy = copy.deepcopy(state_machine.root_state) return state_machine.version, state_copy
def test_run_to_selected_state(caplog): testing_utils.initialize_environment_core() sm_path = testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "run_to_selected_state_test")) sm = storage.load_state_machine_from_path(sm_path) # select state machine for this purpose rafcon.core.singleton.state_machine_manager.add_state_machine(sm) rafcon.core.singleton.state_machine_manager.active_state_machine_id = sm.state_machine_id rafcon.core.singleton.state_machine_execution_engine.run_to_selected_state( "VVBPOY/AOZXRY", sm.state_machine_id) # run the statemachine to the state before AOYXRY, this is an asynchronous task timeout = time.time() while not sm.get_state_by_path( "VVBPOY/ABNQFK" ).state_execution_status is StateExecutionStatus.WAIT_FOR_NEXT_STATE: time.sleep(.05) if time.time() - timeout > 2: raise RuntimeError( "execution_state ABNQFK not reached --> timeout") # wait until the statemachine is executed until ABNQFK the state before AOZXRY, so it doesnt check for the file # before its even written with open(os.path.join(RAFCON_TEMP_PATH_BASE, 'test_file'), 'r') as test_file: lines = test_file.readlines() # the state machines waits at ABNQFK with state WAIT_FOR_NEXT_STATE, so it needs to be stopped manually rafcon.core.singleton.state_machine_execution_engine.stop() rafcon.core.singleton.state_machine_execution_engine.join() try: assert len(lines) < 3 finally: testing_utils.shutdown_environment_only_core(caplog=caplog)
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_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_on_clean_storing_with_name_in_path(caplog): testing_utils.dummy_gui(None) testing_utils.initialize_environment(gui_config={ 'HISTORY_ENABLED': False, 'AUTO_BACKUP_ENABLED': False }, gui_already_started=False) path_old_format = testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "id_to_name_plus_id_storage_format_test_do_not_update")) path_new_format = os.path.join( testing_utils.get_unique_temp_path(), "id_to_name_plus_id_storage_format_test_do_not_update") # gui imports better after initialization from rafcon.gui.models.state_machine import StateMachineModel shutil.copytree(path_old_format, path_new_format) from rafcon.core.storage import storage sm = storage.load_state_machine_from_path(path_new_format) check_state_recursively_if_state_scripts_are_valid(sm.root_state) sm.base_path = path_new_format sm_m = StateMachineModel(sm) try: on_save_activate(sm_m, logger) check_that_all_files_are_there(sm, with_print=False) check_id_and_name_plus_id_format(path_old_format, path_new_format, sm_m) finally: testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def execute_state_machine_from_path(self, state_machine=None, path=None, start_state_path=None, wait_for_execution_finished=True): """ A helper function to start an arbitrary state machine at a given path. :param path: The path where the state machine resides :param start_state_path: The path to the state from which the execution will start :return: a reference to the created state machine """ import rafcon.core.singleton if not state_machine: if not path: raise ValueError( "You must provide either a state machine or a path to a state machine for execution" ) from rafcon.core.storage import storage state_machine = storage.load_state_machine_from_path(path) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_execution_engine.start( state_machine.state_machine_id, start_state_path=start_state_path) if wait_for_execution_finished: self.join() self.stop() return state_machine
def test_scoped_data(caplog): storage_path = testing_utils.get_unique_temp_path() sm = create_state_machine() storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) state_machine = StateMachine(sm_loaded.root_state) testing_utils.test_multithreading_lock.acquire() rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id rafcon.core.singleton.state_machine_execution_engine.start() rafcon.core.singleton.state_machine_execution_engine.join() rafcon.core.singleton.state_machine_manager.remove_state_machine( state_machine.state_machine_id) try: assert state_machine.root_state.output_data[ "data_output_port1"] == 42.0 testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
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_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 setup_class(cls): # This methods runs on class creation and creates the state machine testing_utils.test_multithreading_lock.acquire() state_machine = global_storage.load_state_machine_from_path( testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "action_block_execution_test"))) cls.state_machine = state_machine state_machine_manager.add_state_machine(state_machine)
def execute_state_machine_from_path(self, state_machine=None, path=None, start_state_path=None, wait_for_execution_finished=True): """ A helper function to start an arbitrary state machine at a given path. :param path: The path where the state machine resides :param start_state_path: The path to the state from which the execution will start :return: a reference to the created state machine """ import rafcon.core.singleton from rafcon.core.storage import storage rafcon.core.singleton.library_manager.initialize() if not state_machine: state_machine = storage.load_state_machine_from_path(path) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) rafcon.core.singleton.state_machine_execution_engine.start( state_machine.state_machine_id, start_state_path=start_state_path) if wait_for_execution_finished: self.join() self.stop() return rafcon.core.singleton.state_machine_manager.get_active_state_machine( )
def test_custom_entry_point(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) rafcon.core.singleton.state_machine_manager.active_state_machine_id = state_machine.state_machine_id rafcon.core.singleton.state_machine_execution_engine.step_mode() time.sleep(0.2) # let the state machine start properly # sm structure # GLSUJY # GLSUJY/PXTKIH # GLSUJY/NDIVLD # GLSUJY/SFZGMH # GLSUJY/SMCOIB # GLSUJY/SMCOIB/YSBJGK # GLSUJY/SMCOIB/OUWQUJ # GLSUJY/SMCOIB/UGGFFI rafcon.core.singleton.state_machine_execution_engine.step_over() wait_and_join(state_machine, "GLSUJY/PXTKIH") rafcon.core.singleton.state_machine_execution_engine.step_over() wait_and_join(state_machine, "GLSUJY/NDIVLD") rafcon.core.singleton.state_machine_execution_engine.step_over() wait_and_join(state_machine, "GLSUJY/SFZGMH") rafcon.core.singleton.state_machine_execution_engine.step_over() wait_and_join(state_machine, "GLSUJY/SMCOIB") rafcon.core.singleton.state_machine_execution_engine.step_into() wait_and_join(state_machine, "GLSUJY/PXTKIH") rafcon.core.singleton.state_machine_execution_engine.step_into() wait_and_join(state_machine, "GLSUJY/NDIVLD") rafcon.core.singleton.state_machine_execution_engine.step_into() wait_and_join(state_machine, "GLSUJY/SFZGMH") rafcon.core.singleton.state_machine_execution_engine.step_into( ) # step into hierarchy state GLSUJY/SMCOIB rafcon.core.singleton.state_machine_execution_engine.step_into() wait_and_join(state_machine, "GLSUJY/SMCOIB/YSBJGK") rafcon.core.singleton.state_machine_execution_engine.step_out() wait_and_join(state_machine, "GLSUJY/SMCOIB") 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 open_state_machine(state_machine_path): """Executes the specified state machine :param str state_machine_path: The file path to the state machine :return StateMachine: The loaded state machine """ sm = storage.load_state_machine_from_path(state_machine_path) core_singletons.state_machine_manager.add_state_machine(sm) return sm
def test_unchanged_storage_format(caplog): """This test ensures that the state machine storage format does not change in patch releases""" from rafcon.core.storage import storage from rafcon.gui.models.state_machine import StateMachineModel import rafcon path = get_backward_compatibility_state_machines_path() if not os.path.exists(path): logger.info( "test_unchanged_storage_format: the current python interpreter version is not supported" ) return testing_utils.initialize_environment( gui_config={ 'HISTORY_ENABLED': False, 'AUTO_BACKUP_ENABLED': False }, libraries={ 'unit_test_state_machines': testing_utils.get_test_sm_path("unit_test_state_machines") }, gui_already_started=False) try: current_rafcon_version = StrictVersion(rafcon.__version__).version current_minor = "{}.{}".format(current_rafcon_version[0], current_rafcon_version[1]) for filename in os.listdir(path): if filename.startswith(current_minor): old_state_machine_path = os.path.join(path, filename) break else: assert False, "There is no state machine for the current RAFCON minor version {}".format( current_minor) state_machine = storage.load_state_machine_from_path( old_state_machine_path) state_machine_m = StateMachineModel(state_machine) new_state_machine_path = testing_utils.get_unique_temp_path() storage.save_state_machine_to_path(state_machine, new_state_machine_path, True, True) state_machine_m.store_meta_data(copy_path=new_state_machine_path) old_state_machine_hash = calculate_state_machine_hash( old_state_machine_path) new_state_machine_hash = calculate_state_machine_hash( new_state_machine_path) assert old_state_machine_hash.digest( ) == new_state_machine_hash.digest() except Exception: raise finally: testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def create_state_machine(): state_machine_path = testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "history_test")) state_machine = storage.load_state_machine_from_path(state_machine_path) state_dict = { 'Container': state_machine.get_state_by_path("CONT2"), 'State1': state_machine.get_state_by_path("CONT2/STATE1"), 'State2': state_machine.get_state_by_path("CONT2/STATE2"), 'State3': state_machine.get_state_by_path("CONT2/STATE3"), 'Nested': state_machine.get_state_by_path("CONT2/STATE3/NESTED"), 'Nested2': state_machine.get_state_by_path("CONT2/STATE3/NESTED2") } return state_machine, state_dict
def test_missing_rafcon_library_state_error_raise(caplog): config_before = rafcon.core.config.global_config.get_config_value( "RAISE_ERROR_ON_MISSING_LIBRARY_STATES", None) rafcon.core.config.global_config.set_config_value( "RAISE_ERROR_ON_MISSING_LIBRARY_STATES", True) test_path = testing_utils.get_test_sm_path( os.path.join("unit_test_state_machines", "test_sm_with_missing_lib_state")) try: storage.load_state_machine_from_path(test_path) if config_before is not None: rafcon.core.config.global_config.set_config_value( "RAISE_ERROR_ON_MISSING_LIBRARY_STATES", config_before) pytest.fail( msg= "Loading a state machine with missing library state did not raise a LibraryNotFoundException", pytrace=True) except Exception as e: if config_before is not None: rafcon.core.config.global_config.set_config_value( "RAISE_ERROR_ON_MISSING_LIBRARY_STATES", config_before) assert type(e) is LibraryNotFoundException
def test_rename_library_root(caplog): testing_utils.initialize_environment(gui_already_started=False, libraries={}) try: from rafcon.gui.helpers.state_machine import rename_library_root from rafcon.gui.singleton import global_config state_machine_path = os.path.abspath( os.path.join(testing_utils.TEST_STATE_MACHINES_PATH, STATE_MACHINE_NAME)) rename_library_root(CURRENT_LIBRARY_ROOT_NAME, NEW_LIBRARY_ROOT_NAME) library_manager.clean_loaded_libraries() library_manager.refresh_libraries() testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False) testing_utils.initialize_environment( gui_already_started=False, libraries={"new_generic": testing_utils.GENERIC_PATH}) library = storage.load_state_machine_from_path(state_machine_path) assert library is not None library_paths = global_config.get_config_value('LIBRARY_PATHS') del library_paths[CURRENT_LIBRARY_ROOT_NAME] global_config.save_configuration() rename_library_root(NEW_LIBRARY_ROOT_NAME, CURRENT_LIBRARY_ROOT_NAME) library_manager.clean_loaded_libraries() library_manager.refresh_libraries() library = storage.load_state_machine_from_path(state_machine_path) assert library is not None finally: testing_utils.shutdown_environment(caplog=caplog, unpatch_threading=False)
def test_functionality_example(caplog): """Test for now only tests: - if the state machine can be open - if test can be run and stopped - and everything can be closed again """ import rafcon.core.singleton from rafcon.core.storage import storage # The test maybe should also test if functionality are correct depicted. # TODO check if this is done in the common tests already for name in [ 'backward_step_barrier', 'backward_step_hierarchy', 'backward_step_preemption', 'decider_statemachine', 'hierarchy_abortion_handling' ]: sm_path = join(testing_utils.EXAMPLES_PATH, 'functionality_examples', name) print(sm_path) state_machine = storage.load_state_machine_from_path(sm_path) rafcon.core.singleton.state_machine_manager.add_state_machine( state_machine) testing_utils.test_multithreading_lock.acquire() try: # main_window_controller = rafcon.gui.singleton.main_window_controller for state_machine_id in list( rafcon.core.singleton.state_machine_manager.state_machines. keys()): rafcon.core.singleton.state_machine_execution_engine.start( state_machine_id) max_time = 3 current_time = 0.0 sleep_time = 0.2 while not rafcon.core.singleton.state_machine_execution_engine.finished_or_stopped( ): time.sleep(sleep_time) current_time += sleep_time if current_time >= max_time: break rafcon.core.singleton.state_machine_execution_engine.stop() rafcon.core.singleton.state_machine_execution_engine.join() finally: testing_utils.wait_for_gui( ) # to avoid execution and model notification clinches testing_utils.shutdown_environment(gui_config=False, caplog=caplog, expected_warnings=2, expected_errors=4, unpatch_threading=False)
def test_concurrency_preemption_save_load(caplog): testing_utils.test_multithreading_lock.acquire() storage_path = testing_utils.get_unique_temp_path() preemption_state_sm = create_preemption_state_machine() storage.save_state_machine_to_path(preemption_state_sm, storage_path) storage.load_state_machine_from_path(storage_path) rafcon.core.singleton.state_machine_manager.add_state_machine( preemption_state_sm) rafcon.core.singleton.state_machine_execution_engine.start( preemption_state_sm.state_machine_id) rafcon.core.singleton.state_machine_execution_engine.join() try: assert rafcon.core.singleton.global_variable_manager.get_variable( "preempted_state2_code") == "DF3LFXD34G" rafcon.core.singleton.state_machine_manager.remove_state_machine( preemption_state_sm.state_machine_id) testing_utils.assert_logger_warnings_and_errors(caplog) finally: testing_utils.test_multithreading_lock.release()
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_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 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_transition_creation(caplog): storage_path = testing_utils.get_unique_temp_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) with testing_utils.test_multithreading_lock: 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() testing_utils.assert_logger_warnings_and_errors(caplog) rafcon.core.singleton.state_machine_manager.delete_all_state_machines()
def test_scoped_variables(caplog): storage_path = testing_utils.get_unique_temp_path() sm = create_state_machine() storage.save_state_machine_to_path(sm, storage_path) sm_loaded = storage.load_state_machine_from_path(storage_path) state_machine = StateMachine(sm_loaded.root_state) with testing_utils.test_multithreading_lock: 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) assert state_machine.root_state.output_data["output_data_port1"] == 42 testing_utils.assert_logger_warnings_and_errors(caplog)
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_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 start_server(interacting_function, queue_dict): import sys import os import rafcon from rafcon.utils import log from rafcon.utils import plugins from rafcon.core.config import global_config import rafcon.core.singleton as core_singletons from rafcon.core.storage import storage as global_storage # needed for yaml parsing from rafcon.core.states.hierarchy_state import HierarchyState from rafcon.core.states.execution_state import ExecutionState from rafcon.core.states.preemptive_concurrency_state import PreemptiveConcurrencyState from rafcon.core.states.barrier_concurrency_state import BarrierConcurrencyState from rafcon.core.start import signal_handler, register_signal_handlers register_signal_handlers(signal_handler) logger = log.get_logger("start-no-gui") logger.info("initialize RAFCON ... ") plugins.load_plugins() plugins.run_pre_inits() global_config.load(path=os.path.dirname(os.path.abspath(__file__))) # Initialize libraries core_singletons.library_manager.initialize() from tests import utils as testing_utils state_machine = global_storage.load_state_machine_from_path( testing_utils.get_test_sm_path(os.path.join("unit_test_state_machines", "99_bottles_of_beer_monitoring"))) sm_id = rafcon.core.singleton.state_machine_manager.add_state_machine(state_machine) sm_thread = threading.Thread(target=check_for_sm_finished, args=[state_machine, ]) sm_thread.start() setup_config = dict() setup_config["net_config_path"] = os.path.abspath(path=os.path.join(os.path.dirname(os.path.abspath(__file__)), "server")) plugins.run_post_inits(setup_config) if "twisted" in sys.modules: print("################# twisted found #######################") interacting_thread = threading.Thread(target=interacting_function, args=[queue_dict, sm_id]) interacting_thread.start() from twisted.internet import reactor reactor.run() else: logger.error("Server: Twisted is not in sys.modules or twisted is not working! Exiting program ... !") import os os._exit(0) state_machine.root_state.join() rafcon.core.singleton.state_machine_execution_engine.stop() logger.info("State machine execution finished!")