def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ subarray = SubArray(1) if (resource('ska_low/tm_subarray_node/1').get('State') == "ON"): #this means there must have been an error if (resource('ska_low/tm_subarray_node/1').get('obsState') == "IDLE"): LOGGER.info("tearing down composed subarray (IDLE)") # subarray.deallocate() #TODO: Once the OET latest charts are available this can be reverted tmc.release_resources() if (resource('ska_low/tm_subarray_node/1').get('obsState') == "READY"): #this means test must have passed LOGGER.info("tearing down configured subarray (READY)") take_subarray(1).and_end_sb_when_ready() LOGGER.info("End is invoked on Subarray 1") # subarray.deallocate() #TODO: Once the OET latest charts are available this can be reverted tmc.release_resources() LOGGER.info("ReleaseResources is invoked on Subarray 1") if (resource('ska_low/tm_subarray_node/1').get('obsState') == "CONFIGURING" ): LOGGER.warn( "Subarray is still in configuring! Please restart MVP manualy to complete tear down" ) restart_subarray_low(1) #raise exception since we are unable to continue with tear down raise Exception("Unable to tear down test setup") LOGGER.info("Put Telescope back to standby") set_telescope_to_standby() LOGGER.info("Telescope is in standby")
def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ if (resource('ska_low/tm_subarray_node/1').get("obsState") == "IDLE"): LOGGER.info("Release all resources assigned to subarray") # subarray = SubArray(1) # subarray.deallocate() #TODO: Once the OET latest charts are available this can be reverted tmc.release_resources() LOGGER.info("ResourceIdList is empty for Subarray 1 ") LOGGER.info("Put Telescope back to standby") set_telescope_to_standby() LOGGER.info("Telescope is in standby")
def test_release_resources(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" @sync_release_resources def release_resources(): CentralNodeLow = DeviceProxy("ska_low/tm_central/central_node") release_resources_file = ( "resources/test_data/TMC_integration/mccs_release_resources.json" ) release_resource_str = load_config_from_file(release_resources_file) CentralNodeLow.ReleaseResources(release_resource_str) release_resources() LOGGER.info("Release Resources complete") fixture["state"] = "Subarray Configured for RELEASE RESOURCES" # tear down LOGGER.info("TMC-release resources tests complete: tearing down...") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") 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"] == "Release Resources Completed": LOGGER.info("Tearing down in , state = {}".format(fixture["state"])) tmc.set_to_standby() elif fixture["state"] == "Subarray SCANNING": raise Exception("unable to teardown subarray from being in SCANNING") elif fixture["state"] == "Subarray CONFIGURING": raise Exception("unable to teardown subarray from being in CONFIGURING") pytest.fail("unable to complete test without exceptions")
def test_assign_resources(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Staring up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # when I assign resources to subarray # @log_it('TMC_int_comp',devices_to_log) @sync_assign_resources(150) def compose_sub(): resource("ska_low/tm_subarray_node/1").assert_attribute( "State").equals("ON") resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("EMPTY") assign_resources_file = ( "resources/test_data/TMC_integration/mccs_assign_resources.json" ) assign_resources_str = load_config_from_file(assign_resources_file) CentralNode = DeviceProxy("ska_low/tm_central/central_node") CentralNode.AssignResources(assign_resources_str) LOGGER.info("Invoked AssignResources on CentralNode") compose_sub() # tear down LOGGER.info("Tests complete: tearing down...") tmc.release_resources() tmc.set_to_standby() 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() raise
def teardown_function(function): """ teardown any state that was previously setup with a setup_function call. """ if (resource('ska_low/tm_subarray_node/1').get('State') == "ON"): if (resource('ska_low/tm_subarray_node/1').get('obsState') == "IDLE"): LOGGER.info("tearing down composed subarray (IDLE)") # subarray.deallocate() #TODO: Once the OET latest charts are available this can be reverted tmc.release_resources() LOGGER.info('Invoked ReleaseResources on Subarray') wait_before_test(timeout=10) if (resource('ska_low/tm_subarray_node/1').get('obsState') == "READY"): LOGGER.info("tearing down configured subarray (READY)") take_subarray(1).and_end_sb_when_ready() LOGGER.info('Invoked End on Subarray') wait_before_test(timeout=10) # subarray.deallocate() #TODO: Once the OET latest charts are available this can be reverted tmc.release_resources() LOGGER.info('Invoked ReleaseResources on Subarray') wait_before_test(timeout=10) if (resource('ska_low/tm_subarray_node/1').get('obsState') == "CONFIGURING"): LOGGER.warn( "Subarray is still in CONFIFURING! Please restart MVP manualy to complete tear down" ) restart_subarray_low(1) # raise exception since we are unable to continue with tear down raise Exception("Unable to tear down test setup") if (resource('ska_low/tm_subarray_node/1').get('obsState') == "SCANNING"): LOGGER.warn( "Subarray is still in SCANNING! Please restart MVP manualy to complete tear down" ) restart_subarray_low(1) # raise exception since we are unable to continue with tear down raise Exception("Unable to tear down test setup") LOGGER.info("Put Telescope back to standby") set_telescope_to_standby() else: LOGGER.warn( "Subarray is in inconsistent state! Please restart MVP manualy to complete tear down" ) restart_subarray_low(1)
def test_configure_scan(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" # 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") tmc.compose_sub() fixture["state"] = "Subarray Assigned" # then when I configure a subarray to perform a scan as per 'TMC_integration/mccs_configure.json' # @log_it('TMC_int_configure',devices_to_log) @sync_configure @time_it(90) def configure_sub(): configure1_file = "resources/test_data/TMC_integration/mccs_configure.json" config = load_config_from_file(configure1_file) LOGGER.info("Configuring a scan for subarray 1") fixture["state"] = "Subarray CONFIGURING" SubarrayNode = DeviceProxy("ska_low/tm_subarray_node/1") SubarrayNode.Configure(config) LOGGER.info("Invoked Configure on Subarray") configure_sub() fixture["state"] = "Subarray Configured for SCAN" # tear down LOGGER.info("TMC-configure tests complete: tearing down...") tmc.end() LOGGER.info("Invoked End on Subarray") tmc.release_resources() LOGGER.info("Invoked ReleaseResources on Subarray") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") 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 Configured for SCAN": LOGGER.info("Tearing down in , state = {}".format(fixture["state"])) tmc.end() tmc.release_resources() tmc.set_to_standby() elif fixture["state"] == "Subarray SCANNING": raise Exception("unable to teardown subarray from being in SCANNING") elif fixture["state"] == "Subarray CONFIGURING": raise Exception("unable to teardown subarray from being in CONFIGURING") pytest.fail("unable to complete test without exceptions")
def test_endscan(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" # and a subarray configured to perform a scan as per 'TMC_integration/configure1.json' LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray CONFIGURING" tmc.configure_sub() fixture["state"] = "Subarray Configured for SCAN" # When scan is run for provided duration based on previous configuuration resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("READY") LOGGER.info("Invoked Scan on Subarray") fixture["state"] = "Subarray SCANNING" def endscan(): SubarrayNodeLow = DeviceProxy("ska_low/tm_subarray_node/1") tmc.scan_for_scanning() SubarrayNodeLow.EndScan() endscan() LOGGER.info("EndScan complete") fixture["state"] = "Subarray EndScan invoked" # tear down LOGGER.info("TMC-EndScan tests complete: tearing down...") tmc.end() resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Invoked End on Subarray") tmc.release_resources() LOGGER.info("Invoked ReleaseResources on Subarray") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") 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 Configured for SCAN": tmc.end() tmc.release_resources() tmc.set_to_standby() elif fixture["state"] == "Subarray SCANNING": raise Exception( "unable to teardown subarray from being in SCANNING") elif fixture["state"] == "Subarray CONFIGURING": raise Exception( "unable to teardown subarray from being in CONFIGURING") pytest.fail("unable to complete test without exceptions")
def test_restart(): 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("Starting 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") tmc.compose_sub() fixture["state"] = "Subarray Assigned" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Aborting the subarray") fixture["state"] = "Subarray ABORTING" LOGGER.info("Invoking abort command") tmc.abort_sub() fixture["state"] = "Subarray Aborted" fixture["state"] = "Subarray Restarting" @sync_restart() def restart(): SubarrayNodeLow = DeviceProxy("ska_low/tm_subarray_node/1") LOGGER.info( "Subarray obsState before Aborted assertion check is: " + str(SubarrayNodeLow.obsState)) resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("ABORTED") SubarrayNodeLow.Restart() LOGGER.info("Subarray obsState is: " + str(SubarrayNodeLow.obsState)) LOGGER.info("Invoked restart on Subarray") restart() LOGGER.info("Restart is complete on Subarray") LOGGER.info("TMC-Restart tests complete: tearing down...") resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("EMPTY") fixture["state"] = "Subarray empty" tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") fixture["state"] = "Subarray off" LOGGER.info("TMC-Low-Restart 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": # restart_subarray(1) raise Exception( "unable to teardown subarray from being in ABORTING") elif fixture["state"] == "Subarray Aborted": # restart_subarray(1) raise Exception( "unable to teardown subarray from being in Aborted") elif fixture["state"] == "Subarray Restarting": # restart_subarray(1) raise Exception( "unable to teardown subarray from being in Restarting") elif fixture["state"] == "Subarray off": LOGGER.info("Subarray has completed StandBy execution") pytest.fail("unable to complete test without exceptions")
def test_scan(): try: # given an interface to TMC to interact with a subarray node and a central node fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" # and a subarray configured to perform a scan as per 'TMC_integration/configure1.json' LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray CONFIGURING" tmc.configure_sub() fixture["state"] = "Subarray Configured for SCAN" # When I run a scan of 4 seconds based on previos configuration resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("READY") LOGGER.info("Starting a scan of 4 seconds") fixture["state"] = "Subarray SCANNING" # @log_it('TMC_int_scan',devices_to_log) @sync_scan(200) def scan(): SubarrayNodeLow = DeviceProxy("ska_low/tm_subarray_node/1") scan_command_file = ( "resources/test_data/TMC_integration/mccs_scan.json") scan_str = load_config_from_file(scan_command_file) SubarrayNodeLow.Scan(scan_str) scan() LOGGER.info("Scan complete") fixture["state"] = "Subarray Configured for SCAN" # tear down LOGGER.info("TMC-Scan tests complete: tearing down...") tmc.end() resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Invoked End on Subarray") tmc.release_resources() LOGGER.info("Invoked ReleaseResources on Subarray") tmc.set_to_standby() LOGGER.info("Invoked StandBy on Subarray") 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 Configured for SCAN": tmc.end() tmc.release_resources() tmc.set_to_standby() elif fixture["state"] == "Subarray SCANNING": raise Exception( "unable to teardown subarray from being in SCANNING") elif fixture["state"] == "Subarray CONFIGURING": raise Exception( "unable to teardown subarray from being in CONFIGURING") pytest.fail("unable to complete test without exceptions")
def test_abort(required_obstate): try: obs_state_val = required_obstate # given an interface to TMC to interact with a subarray node and a central node if obs_state_val == "IDLE": fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Invoking abort command") tmc.abort_sub() fixture["state"] = "Obstate aborted" LOGGER.info("Invoking Obsreset command") tmc.obsreset_sub() 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") elif obs_state_val == "READY": fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray CONFIGURING" tmc.configure_sub() fixture["state"] = "Subarray Configured for SCAN" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("READY") LOGGER.info("Invoking abort command") tmc.abort_sub() fixture["state"] = "Obstate aborted" LOGGER.info("Invoking Obsreset command") tmc.obsreset_sub() 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") elif obs_state_val == "SCANNING": fixture = {} fixture["state"] = "Unknown" # given a started up telescope assert telescope_is_in_standby() LOGGER.info("Starting up the Telescope") tmc.start_up() fixture["state"] = "Telescope On" # and a subarray composed of two resources configured as perTMC_integration/mccs_assign_resources.json LOGGER.info("Composing the Subarray") tmc.compose_sub() fixture["state"] = "Subarray Assigned" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("IDLE") LOGGER.info("Configuring the Subarray") fixture["state"] = "Subarray CONFIGURING" tmc.configure_sub() fixture["state"] = "Subarray Configured for SCAN" resource("ska_low/tm_subarray_node/1").assert_attribute( "obsState").equals("READY") @sync_abort def abort(): SubarrayNodeLow = DeviceProxy("ska_low/tm_subarray_node/1") tmc.scan_for_scanning() SubarrayNodeLow.Abort() LOGGER.info("Invoked Abort on Subarray") abort() LOGGER.info("Abort is complete on Subarray") fixture["state"] = "Subarray Aborted" tmc.obsreset_sub() 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") else: msg = "obsState {} is not settable with command methods" raise ValueError(msg.format(obs_state_val)) 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 CONFIGURING": raise Exception( "unable to teardown subarray from being in Restarting") 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")