def test_tearing_down_subarray(subscriber_mock, resource_mock, watch_mock): the_waiter = waiter() the_waiter.set_wait_for_tearing_down_subarray() assert_that(resource_mock.call_count).is_equal_to(5) #assert_that(subscriber_mock.call_count).is_equal_to(5+4) #assert_that(watch_mock.call_count).is_equal_to(5+4) the_waiter.wait()
def wrapper(*args, **kwargs): check_going_out_of_configured() the_waiter = waiter() the_waiter.set_wait_for_going_into_scanning() result = func(*args, **kwargs) the_waiter.wait() return result
def wrapper(*args, **kwargs): check_going_out_of_configured() the_waiter = waiter() the_waiter.set_wait_for_ending_SB() result = func(*args, **kwargs) the_waiter.wait(200) return result
def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ if (resource('ska_mid/tm_subarray_node/1').get("State") == "ON"): the_waiter = waiter() the_waiter.set_wait_for_tearing_down_subarray() SubArray(1).deallocate() the_waiter.wait() LOGGER.info(the_waiter.logs) if (resource('ska_mid/tm_subarray_node/1').get("State") == "OFF"): the_waiter = waiter() the_waiter.set_wait_for_going_to_standby() SKAMid().standby() the_waiter.wait() LOGGER.info(the_waiter.logs)
def wrapper(*args, **kwargs): check_coming_out_of_standby() the_waiter = waiter() the_waiter.set_wait_for_starting_up() result = func(*args, **kwargs) the_waiter.wait(50) return result
def wrapper(*args, **kwargs): check_going_out_of_abort() the_waiter = waiter() the_waiter.set_wait_for_going_into_obsreset() result = func(*args, **kwargs) the_waiter.wait(100) return result
def wrapper(*args, **kwargs): check_going_into_standby() the_waiter = waiter() the_waiter.set_wait_for_going_to_standby() result = func(*args, **kwargs) the_waiter.wait(100) return result
def start_up(): the_waiter = waiter() the_waiter.set_wait_for_starting_up() SKAMid().start_up() the_waiter.wait() LOGGER.info("Telescope Started up") LOGGER.debug("the_waiter.logs")
def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ the_waiter = waiter() if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "IDLE"): the_waiter.set_wait_for_tearing_down_subarray() LOGGER.info("tearing down composed subarray (IDLE)") SubArray(1).deallocate() the_waiter.wait() LOGGER.info(the_waiter.logs) if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "READY"): LOGGER.info("tearing down configured subarray (READY)") the_waiter.set_wait_for_ending_SB() SubArray(1).end_sb() the_waiter.wait() LOGGER.info(the_waiter.logs) the_waiter.set_wait_for_tearing_down_subarray() SubArray(1).deallocate() the_waiter.wait() LOGGER.info(the_waiter.logs) if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "CONFIGURING"): LOGGER.info("tearing down configuring subarray") restart_subarray(1) if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "SCANNING"): LOGGER.info("tearing down scanning subarray") restart_subarray(1) the_waiter.set_wait_for_going_to_standby() SKAMid().standby() LOGGER.info("standby command is executed on telescope") the_waiter.wait() LOGGER.info(the_waiter.logs)
def wrapper(*args, **kwargs): print("In sync_release_resources") check_going_into_empty() the_waiter = waiter() the_waiter.set_wait_for_tearing_down_subarray() result = func(*args, **kwargs) the_waiter.wait(150) return result
def wrapper(*args, **kwargs): check_going_out_of_empty() the_waiter = waiter() the_waiter.set_wait_for_assign_resources( nr_of_receptors=nr_of_receptors) ################ result = func(*args, **kwargs) ################ the_waiter.wait(timeout=timeout) return result
def compose_sub(): resource("ska_mid/tm_subarray_node/1").assert_attribute("State").equals( "ON") resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals( "EMPTY") assign_resources_file = "resources/test_data/TMC_integration/assign_resources1.json" sdp_block = update_resource_config_file(assign_resources_file) LOGGER.info("_______sdp_block________" + str(sdp_block)) config = load_config_from_file(assign_resources_file) CentralNode = DeviceProxy("ska_mid/tm_central/central_node") CentralNode.AssignResources(config) the_waiter = waiter() the_waiter.wait() LOGGER.info("Invoked AssignResources on CentralNode") return sdp_block
def set_telescope_to_running(disable_waiting=False): the_waiter = waiter() the_waiter.set_wait_for_starting_up() # TODO: Using TMC API for TelescopeOn command. # Telescope().start_up() CentralNode = DeviceProxy("ska_mid/tm_central/central_node") LOGGER.info("Before Sending TelescopeOn command on CentralNode state :" + str(CentralNode.telescopeState)) CentralNode.TelescopeOn() the_waiter.wait(5000) if not disable_waiting: the_waiter.wait(8000) if the_waiter.timed_out: pytest.fail("timed out whilst starting up telescope:\n {}".format( the_waiter.logs))
def compose_sub(): resource('ska_mid/tm_subarray_node/1').assert_attribute('State').equals( 'ON') resource('ska_mid/tm_subarray_node/1').assert_attribute('obsState').equals( 'EMPTY') assign_resources_file = download_test_data( "mid_assign_resources_v1.json", "skampi-test-data/tmc-integration/assign-resources") sdp_block = update_resource_config_file(assign_resources_file) LOGGER.info("_______sdp_block________" + str(sdp_block)) config = load_config_from_file(assign_resources_file) os.remove(assign_resources_file) CentralNode = DeviceProxy('ska_mid/tm_central/central_node') CentralNode.AssignResources(config) the_waiter = waiter() the_waiter.wait() LOGGER.info('Invoked AssignResources on CentralNode') return sdp_block
def restart_subarray(id): devices = device_to_subarrays.keys() filtered_devices = [ device for device in devices if device_to_subarrays[device] == id ] the_waiter = waiter() the_waiter.set_wait_for_going_to_standby() exceptions_raised = "" LOGGER.info("Inside restart subarray method.") for device in filtered_devices: try: resource(device).restart() LOGGER.info("Restart subarray API invoked on device :" + str(device)) except Exception as e: exceptions_raised += f"\nException raised on reseting {device}:{e}" if exceptions_raised != "": raise Exception(f"Error in initialising devices:{exceptions_raised}") the_waiter.wait()
def set_telescope_to_standby(): the_waiter = waiter() the_waiter.set_wait_for_going_to_standby() # TODO: Using TMC API for TelescopeOff command. # Telescope().standby() CentralNode = DeviceProxy("ska_mid/tm_central/central_node") CentralNode.TelescopeOff() LOGGER.info("After Standby CentralNode State:" + str(CentralNode.telescopeState)) LOGGER.info("Standby the Telescope") # It is observed that CSP and CBF subarrays sometimes take more than 8 sec to change the State to DISABLE # therefore timeout is given as 12 sec the_waiter.wait(5000) if the_waiter.timed_out: pytest.fail( "timed out whilst setting telescope to standby:\n {}".format( the_waiter.logs))
def telescope_is_in_standby(): the_waiter = waiter() the_waiter.wait(5000) LOGGER.info( 'resource("ska_mid/tm_central/central_node").get("telescopeState")' + str(resource("ska_mid/tm_central/central_node").get("telescopeState"))) LOGGER.info('resource("mid_csp/elt/subarray_01").get("State")' + str(resource("mid_csp/elt/subarray_01").get("State"))) LOGGER.info('resource("mid_sdp/elt/subarray_1").get("State")' + str(resource("mid_sdp/elt/subarray_1").get("State"))) LOGGER.info('resource("mid_csp/elt/master").get("State")' + str(resource("mid_csp/elt/master").get("State"))) LOGGER.info('resource("mid_sdp/elt/master").get("State")' + str(resource("mid_sdp/elt/master").get("State"))) LOGGER.info('resource("mid_d0001/elt/master").get("State")' + str(resource("mid_d0001/elt/master").get("State"))) LOGGER.info('resource("mid_d0002/elt/master").get("State")' + str(resource("mid_d0002/elt/master").get("State"))) LOGGER.info('resource("mid_d0003/elt/master").get("State")' + str(resource("mid_d0003/elt/master").get("State"))) LOGGER.info('resource("mid_d0004/elt/master").get("State")' + str(resource("mid_d0004/elt/master").get("State"))) return [ resource("ska_mid/tm_central/central_node").get("telescopeState"), resource("mid_csp/elt/subarray_01").get("State"), resource("mid_sdp/elt/subarray_1").get("State"), resource("mid_csp/elt/master").get("State"), resource("mid_d0001/elt/master").get("State"), resource("mid_d0002/elt/master").get("State"), resource("mid_d0003/elt/master").get("State"), resource("mid_d0004/elt/master").get("State"), ] == [ "STANDBY", "OFF", "OFF", "STANDBY", "STANDBY", "STANDBY", "STANDBY", "STANDBY", ]
def tmc_is_on(): the_waiter = waiter() the_waiter.set_wait_for_tmc_starting_up() the_waiter.wait(5000) LOGGER.info('resource("ska_mid/tm_central/central_node").get("State")' + str(resource("ska_mid/tm_central/central_node").get("State"))) LOGGER.info('resource("ska_mid/tm_subarray_node/1").get("State")' + str(resource("ska_mid/tm_subarray_node/1").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/sdp_master").get("State")' + str(resource("ska_mid/tm_leaf_node/sdp_master").get("State"))) LOGGER.info( 'resource("ska_mid/tm_leaf_node/sdp_subarray01").get("State")' + str(resource("ska_mid/tm_leaf_node/sdp_subarray01").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/csp_master").get("State")' + str(resource("ska_mid/tm_leaf_node/csp_master").get("State"))) LOGGER.info( 'resource("ska_mid/tm_leaf_node/csp_subarray01").get("State")' + str(resource("ska_mid/tm_leaf_node/csp_subarray01").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/d0001").get("State")' + str(resource("ska_mid/tm_leaf_node/d0001").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/d0002").get("State")' + str(resource("ska_mid/tm_leaf_node/d0002").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/d0003").get("State")' + str(resource("ska_mid/tm_leaf_node/d0003").get("State"))) LOGGER.info('resource("ska_mid/tm_leaf_node/d0004").get("State")' + str(resource("ska_mid/tm_leaf_node/d0004").get("State"))) return [ resource("ska_mid/tm_central/central_node").get("State"), resource("ska_mid/tm_subarray_node/1").get("State"), resource("ska_mid/tm_leaf_node/sdp_master").get("State"), resource("ska_mid/tm_leaf_node/sdp_subarray01").get("State"), resource("ska_mid/tm_leaf_node/csp_master").get("State"), resource("ska_mid/tm_leaf_node/csp_subarray01").get("State"), resource("ska_mid/tm_leaf_node/d0001").get("State"), resource("ska_mid/tm_leaf_node/d0002").get("State"), resource("ska_mid/tm_leaf_node/d0003").get("State"), resource("ska_mid/tm_leaf_node/d0004").get("State"), ] == ["ON", "ON", "ON", "ON", "ON", "ON", "ON", "ON", "ON", "ON"]
def test_start_up_telescope(run_context): LOGGER.info( "Before starting the telescope checking if the TMC is in ON state") assert (tmc_is_on()) LOGGER.info( "Before starting the telescope checking if the telescope is in StandBy." ) assert (telescope_is_in_standby) jsonLogin = {"username": "******", "password": "******"} url = 'http://taranta-taranta-{}:8080/login'.format( run_context.HELM_RELEASE) r = requests.post(url=url, json=jsonLogin) taranta_jwt = r.cookies.get_dict()['taranta_jwt'] cookies = {'taranta_jwt': taranta_jwt} url = 'http://taranta-taranta-{}:5004/db'.format(run_context.HELM_RELEASE) # with open('test-harness/files/mutation.json', 'r') as file: # mutation = file.read().replace('\n', '') mutation = '{"query":"mutation {\\n executeCommand(device: \\"ska_mid/tm_central/central_node\\", command: \\"TelescopeOn\\") {\\n ok\\n output\\n message\\n }\\n}\\n","variables":"null"}' LOGGER.info("Mutation " + str(mutation)) jsonMutation = json.loads(mutation) LOGGER.info("jsonMutation " + str(jsonMutation)) the_waiter = waiter() the_waiter.set_wait_for_starting_up() r = requests.post(url=url, json=jsonMutation, cookies=cookies) the_waiter.wait() LOGGER.info("r.text " + str(r.text)) parsed = json.loads(r.text) LOGGER.info("parsed r.text is " + str(parsed)) print(json.dumps(parsed, indent=4, sort_keys=True)) LOGGER.info("sorted pasrsed r.text " + str(json.dumps(parsed, indent=4, sort_keys=True))) try: assert parsed['data']['executeCommand']['ok'] == True finally: # tear down command is ignored if it is already in standby if not telescope_is_in_standby(): # wait first for telescope to completely go to standby before switchig it off again set_telescope_to_standby() LOGGER.info("Telescope is in STANDBY")
def allocate_four_dishes(result): the_waiter = waiter() the_waiter.set_wait_for_assign_resources() result['response'] = SubArray(1).allocate( ResourceAllocation(dishes=[Dish(1), Dish(2), Dish(3), Dish(4)])) #wait for certain values to be changed (refer to helpers for what is currently defined as neccesarry to wait) the_waiter.wait() LOGGER.info(the_waiter.logs) result = wait_for(resource('mid_csp/elt/master'), 20).to_be({ "attr": "receptorMembership", "value": (1, 1, 1, 1) }) if (result == "timed out"): LOGGER.info( "timed out after 2 seconds waiting for mid_csp/elt/master receptorMembership to change to (1,1,1,1)" ) return result
def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ the_waiter = waiter() if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "IDLE"): #this means there must have been an error the_waiter.set_wait_for_tearing_down_subarray() LOGGER.info("tearing down composed subarray (IDLE)") SubArray(1).deallocate() the_waiter.wait() LOGGER.info(the_waiter.logs) if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "READY"): #this means test must have passed LOGGER.info("tearing down configured subarray (READY)") the_waiter.set_wait_for_ending_SB() SubArray(1).end_sb() the_waiter.wait() LOGGER.debug(the_waiter.logs) the_waiter.set_wait_for_tearing_down_subarray() SubArray(1).deallocate() the_waiter.wait() LOGGER.debug(the_waiter.logs) if (resource('ska_mid/tm_subarray_node/1').get('obsState') == "CONFIGURING" ): LOGGER.warn( "Subarray is still in configuring! Please restart MVP manualy to complete tear down" ) restart_subarray(1) #raise exception since we are unable to continue with tear down raise Exception("Unable to tear down test setup") LOGGER.info("Putting Telescope in standby") the_waiter.set_wait_for_going_to_standby() SKAMid().standby() the_waiter.wait() LOGGER.debug(the_waiter.logs)
def sync_going_to_standby(timeout=50): check_going_into_standby() the_waiter = waiter() the_waiter.set_wait_for_going_to_standby() yield the_waiter.wait(timeout)
def sync_resources_releasing(timeout=100): the_waiter = waiter() the_waiter.set_wait_for_tearing_down_subarray() yield the_waiter.wait(timeout)
def test_obsreset(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" the_waiter = waiter() # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Staring up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/assign_resources.json LOGGER.info("Composing the Subarray") sdp_block = tmc.compose_sub() fixture["state"] = "Subarray Assigned" @log_it("TMC_int_configure", devices_to_log, non_default_states_to_check) def configure_sub(sdp_block): # commented because below asserts are already checked in @sync_configure # resource('ska_mid/tm_subarray_node/1').assert_attribute('State').equals('ON') # resource('ska_mid/tm_subarray_node/1').assert_attribute('obsState').equals('IDLE') configure1_file = "resources/test_data/TMC_integration/configure2.json" update_scan_config_file(configure1_file, sdp_block) config = load_config_from_file(configure1_file) LOGGER.info("Configuring a scan for subarray 1") fixture["state"] = "Subarray CONFIGURING" SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1") SubarrayNode.Configure(config) LOGGER.info("Invoked Configure on Subarray") configure_sub(sdp_block) fixture["state"] = "Subarray Configured for SCAN" resource("ska_mid/tm_subarray_node/1").assert_attribute( "obsState").equals("CONFIGURING") LOGGER.info("Aborting the subarray") fixture["state"] = "Subarray ABORTING" @log_it("TMC_int_abort", devices_to_log, non_default_states_to_check) @sync_abort() def abort(): resource("ska_mid/tm_subarray_node/1").assert_attribute( "State").equals("ON") resource("ska_mid/tm_subarray_node/1").assert_attribute( "obsState").equals("CONFIGURING") SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1") SubarrayNode.Abort() LOGGER.info("Invoked Abort on Subarray") abort() the_waiter.wait() LOGGER.info("Abort is complete on Subarray") fixture["state"] = "Subarray Aborted" fixture["state"] = "Subarray Resetting" @sync_obsreset() def obsreset(): resource("ska_mid/tm_subarray_node/1").assert_attribute( "State").equals("ON") # resource('mid_csp/elt/subarray_01').assert_attribute('obsState').equals('ABORTED') # resource('mid_sdp/elt/subarray_1').assert_attribute('obsState').equals('ABORTED') SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1") # the_waiter.wait() LOGGER.info( "Subarray obsState before Aborted assertion check is: " + str(SubarrayNode.obsState)) resource("ska_mid/tm_subarray_node/1").assert_attribute( "obsState").equals("ABORTED") SubarrayNode.ObsReset() LOGGER.info("Subarray obsState is: " + str(SubarrayNode.obsState)) LOGGER.info("Invoked obsreset on Subarray") obsreset() LOGGER.info("Obsreset is complete on Subarray") fixture["state"] = "Subarray IDLE" tmc.release_resources() LOGGER.info("Invoked ReleaseResources on Subarray") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") # tear down LOGGER.info("TMC-ObsReset tests complete: tearing down...") except: LOGGER.info("Tearing down failed test, state = {}".format( fixture["state"])) if fixture["state"] == "Telescope On": tmc.set_to_standby() elif fixture["state"] == "Subarray Assigned": tmc.release_resources() tmc.set_to_standby() elif fixture["state"] == "Subarray ABORTING": raise Exception( "unable to teardown subarray from being in ABORTING") elif fixture["state"] == "Subarray Aborted": raise Exception( "unable to teardown subarray from being in Aborted") elif fixture["state"] == "Subarray Resetting": raise Exception( "unable to teardown subarray from being in Restarting") elif fixture["state"] == "Subarray IDLE": tmc.release_resources() tmc.set_to_standby() pytest.fail("unable to complete test without exceptions")
def sync_sb_ending(): check_going_out_of_configured() the_waiter = waiter() the_waiter.set_wait_for_ending_SB() yield the_waiter.wait()
def sync_telescope_starting_up(timeout=50): check_coming_out_of_standby() the_waiter = waiter() the_waiter.set_wait_for_starting_up() yield the_waiter.wait(timeout)
def sync_assigned_resources(nr_of_receptors=4): check_going_out_of_empty() the_waiter = waiter() the_waiter.set_wait_for_assign_resources(nr_of_receptors=nr_of_receptors) yield the_waiter.wait(timeout=60)
def test_multi_scan(): #### try: the_waiter = waiter() fixture = {} fixture["state"] = "Unknown" # given a started up telescope LOGGER.info("Checking if Telescope is in StandBy") assert telescope_is_in_standby() LOGGER.info("Telescope is in StandBy") tmc.start_up() LOGGER.info("Staring up the Telescope") fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/assign_resources1.json sdp_block = tmc.compose_sub() LOGGER.info("Composing the Subarray") fixture["state"] = "Subarray Assigned" # and for which the subarray is configured to perform a scan as per 'TMC_integration/configure1.json' fixture["state"] = "Subarray CONFIGURING" configure_file = "resources/test_data/TMC_integration/configure2.json" tmc.configure_sub(sdp_block, configure_file) LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray Configured for SCAN" # and for which the subarray has successfully completed a scan durating 6 seconds based on previos configuration resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals( "READY" ) LOGGER.info("Starting a scan of 6 seconds") with log_states("TMC_ss-41-scan1", devices_to_log, non_default_states_to_check): with sync_scanning(200): SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1") SubarrayNode.Scan('{"id":1}') fixture["state"] = "Subarray SCANNING" LOGGER.info("Subarray obsState is: " + str(SubarrayNode.obsState)) LOGGER.info("Scan 1 is executing on Subarray") LOGGER.info("Scan1 complete") fixture["state"] = "Subarray Configured for SCAN" # then when I load a new configuration to perform a can as per TMC_integration/configure2.json LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray CONFIGURING" configure_file = "resources/test_data/TMC_integration/configure1.json" tmc.configure_sub(sdp_block, configure_file) LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray Configured for SCAN" # and run a new scan bsed on that configuration resource("mid_csp/elt/subarray_01").assert_attribute("obsState").equals("READY") resource("mid_csp_cbf/sub_elt/subarray_01").assert_attribute("obsState").equals( "READY" ) resource("mid_sdp/elt/subarray_1").assert_attribute("obsState").equals("READY") resource("ska_mid/tm_subarray_node/1").assert_attribute("obsState").equals( "READY" ) LOGGER.info("Starting a scan of 6 seconds") with log_states("TMC_ss-41-scan2", devices_to_log, non_default_states_to_check): with sync_scanning(200): LOGGER.info("Check obsstate again before starting 2nd scan") resource("ska_mid/tm_subarray_node/1").assert_attribute( "obsState" ).equals("READY") resource("mid_csp/elt/subarray_01").assert_attribute("obsState").equals( "READY" ) resource("mid_csp_cbf/sub_elt/subarray_01").assert_attribute( "obsState" ).equals("READY") resource("mid_sdp/elt/subarray_1").assert_attribute("obsState").equals( "READY" ) SubarrayNode = DeviceProxy("ska_mid/tm_subarray_node/1") SubarrayNode.Scan('{"id":1}') fixture["state"] = "Subarray SCANNING" LOGGER.info("Subarray obsState is: " + str(SubarrayNode.obsState)) LOGGER.info("Scan2 complete") fixture["state"] = "Subarray Configured for SCAN" # the scanning should complete without any exceptions # TODO possibly add some other asserts in here # tear down LOGGER.info("TMC-multiscan tests complete: tearing down...") tmc.end_sb() the_waiter.wait() LOGGER.info("Invoked EndSB on Subarray") tmc.release_resources() the_waiter.wait() LOGGER.info("Invoked ReleaseResources on Subarray") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") the_waiter.wait() LOGGER.info("Invoked StandBy on Subarray") LOGGER.info("Tests complete: tearing down...") except Exception as e: logging.info(f"Exception raised: {e.args}") LOGGER.info("Gathering logs") LOGGER.info("Tearing down failed test, state = {}".format(fixture["state"])) if fixture["state"] == "Telescope On": tmc.set_to_standby() the_waiter.wait() elif fixture["state"] == "Subarray Assigned": tmc.release_resources() the_waiter.wait() tmc.set_to_standby() the_waiter.wait() elif fixture["state"] == "Subarray Configured for SCAN": tmc.end_sb() the_waiter.wait() tmc.release_resources() the_waiter.wait() tmc.set_to_standby() the_waiter.wait() elif fixture["state"] == "Subarray SCANNING": if resource("ska_mid/tm_subarray_node/1").get("obsState") == "SCANNING": raise Exception("unable to teardown subarray from being in SCANNING") else: # sleep arbitrary number here to handle possible failures in un-idempotentcy sleep(3) tmc.end_sb() the_waiter.wait() tmc.release_resources() the_waiter.wait() tmc.set_to_standby() the_waiter.wait() raise e elif fixture["state"] == "Subarray CONFIGURING": raise Exception("unable to teardown subarray from being in CONFIGURING") elif fixture["state"] == "Unknown": LOGGER.info("Put telescope back to standby") tmc.set_to_standby() the_waiter.wait() pytest.fail("unable to complete test without exceptions")
def sync_oet_scanning(timeout=200): check_going_out_of_configured() the_waiter = waiter() the_waiter.set_wait_for_going_into_scanning() yield the_waiter.wait()
def start_up(): the_waiter = waiter() the_waiter.set_wait_for_starting_up() SKAMid().start_up() the_waiter.wait() LOGGER.info(the_waiter.logs)