def run_tests():
app_text_output.enable()
app_text_output.value = "Running Tests, Please wait..."
app_textbox_address.disable()
app_button_test_sensor.disable()
app_text_output.disable()
rm_cached_variables.http_login = app_textbox_user.value
rm_cached_variables.http_password = app_textbox_password.value
sensor_address = app_textbox_address.value
test_http_server.sensor_address = sensor_address
print("Sensor: " + str(sensor_address) + "\n\n")
if get_http_sensor_reading(sensor_address, timeout=5) == "OK":
if get_http_sensor_reading(sensor_address,
http_command=sg_commands.check_portal_login,
timeout=5) == "OK":
temp_version = get_http_sensor_reading(
sensor_address,
http_command=sg_commands.program_version,
timeout=5)
remote_sensor_version.load_from_string(temp_version)
if remote_sensor_version.major_version == refined_compatible_version.major_version and \
remote_sensor_version.feature_version == refined_compatible_version.feature_version and \
remote_sensor_version.minor_version >= refined_compatible_version.minor_version:
print(" ------ Starting Tests ------")
print(" " + strftime("%B %d, %Y %H:%M:%S") + "\n")
print(" Configuration Tests\n")
suite = unittest.TestLoader().loadTestsFromTestCase(
test_http_server.TestApp)
suite.run(unittest.TestResult())
print("\n\n Display & Sensor Reading Tests\n")
suite2 = unittest.TestLoader().loadTestsFromTestCase(
test_http_server.TestApp2)
suite2.run(unittest.TestResult())
else:
print("-- Incompatible Version Detected --\n")
print_msg = "-- Compatible Version: " + refined_compatible_version.get_version_string(
)
print(print_msg + " (" +
str(refined_compatible_version.minor_version) +
" or higher) --")
print("-- Remote Version: " +
remote_sensor_version.get_version_string() + " --")
else:
print("-- Incorrect Sensor Login --")
else:
print("-- Sensor Offline --\n\n")
if sensor_address == "localhost":
print("Local Primary Log\n" +
logger.get_sensor_log(file_locations.primary_log))
print("\n\n ------ End of Tests ------")
print(" " + strftime("%B %d, %Y %H:%M:%S") + "\n")
app_text_output.enable()
app_text_output.value = redirect_string.getvalue()
app_button_test_sensor.enable()
app_textbox_address.enable()
redirect_string.truncate(0)
redirect_string.seek(0)
def _login_successful(ip):
if get_http_sensor_reading(
ip, http_command=network_commands.check_portal_login) == "OK":
return True
logger.network_logger.warning("The Sensor " + str(ip) +
" did not accept provided Login Credentials")
return False
def _config_test_changes(self,
config_instance,
config_get_command,
config_set_command,
config_name=""):
original_config = get_http_sensor_reading(
sensor_address, http_command=config_get_command)
config_instance.set_settings_for_test1()
send_config = config_instance.get_config_as_str()
send_http_test_config(sensor_address, config_set_command, send_config)
first_set_config = get_http_sensor_reading(
sensor_address, http_command=config_get_command)
if self._bad_config(config_instance.get_config_as_str(),
first_set_config,
config_name=config_name + " 1"):
send_http_test_config(sensor_address, config_set_command,
original_config)
return False
config_instance.set_settings_for_test2()
send_config = config_instance.get_config_as_str()
send_http_test_config(sensor_address, config_set_command, send_config)
second_set_config = get_http_sensor_reading(
sensor_address, http_command=config_get_command)
if self._bad_config(config_instance.get_config_as_str(),
second_set_config,
config_name=config_name + " 2"):
send_http_test_config(sensor_address, config_set_command,
original_config)
return False
send_http_test_config(sensor_address, config_set_command,
original_config)
original_set_config = get_http_sensor_reading(
sensor_address, http_command=config_get_command)
if self._bad_config(original_config,
original_set_config,
config_name=config_name + " 3"):
send_http_test_config(sensor_address, config_set_command,
original_config)
return False
return True
def _worker_queue_list_ip_name_file(address, command):
try:
sensor_name = get_http_sensor_reading(address,
http_command="GetHostName")
sensor_data = get_http_kootnet_sensor_file(address,
http_command=command)
data_queue.put([address, sensor_name, sensor_data])
except Exception as error:
logger.network_logger.error(
"Sensor Control - Get Remote File Failed: " + str(error))
def _check_address(self, sensor_address):
""" Checks if a remote sensor is online and if so, saves the results to a queue. """
try:
sensor_online_check = get_http_sensor_reading(sensor_address)
if sensor_online_check == "OK":
self.local_queue.put(sensor_address)
except Exception as error:
logger.network_logger.error(
"Sensor Control - Error Checking Online Status: " + str(error))
def _get_sensor_reading(sensor_get_command):
no_sensor_return = "NoSensor"
graph_sensor_address = app_config_access.live_graphs_config.graph_sensor_address
remote_reading = get_http_sensor_reading(graph_sensor_address,
http_command=sensor_get_command,
timeout=0.5)
if remote_reading == get_sensor_reading_error_msg:
return no_sensor_return, 503
elif remote_reading == no_sensor_return:
return no_sensor_return, 404
return remote_reading
def _get_remote_management_report(ip_address,
sensor_report_url,
data_queue,
login_required=False):
sensor_check = _get_sensor_response_time(ip_address)
rsm_address_port = ip_address.strip()
if len(ip_address.split(":")) == 1:
rsm_address_port = ip_address.strip() + ":10065"
if sensor_check:
login_check = get_http_sensor_reading(
ip_address, http_command=sg_commands.check_portal_login)
if login_check == "OK" or not login_required:
if login_check == "OK":
login_check = "Login OK"
elif auth_error_msg_contains in login_check:
login_check = "Login Failed"
else:
login_check = "Unknown Error"
sensor_report = get_http_sensor_reading(
ip_address, http_command=sensor_report_url)
sensor_report = sensor_report.replace(
"{{ ResponseBackground }}",
get_html_response_bg_colour(sensor_check))
sensor_report = sensor_report.replace("{{ LoginCheck }}",
login_check)
sensor_report = sensor_report.replace("{{ SensorResponseTime }}",
sensor_check)
else:
sensor_report = rm_cached_variables.report_sensor_error_template.replace(
"{{ Heading }}", "Login Failed")
else:
logger.network_logger.debug("Remote Sensor " + ip_address + " Offline")
sensor_check = "99.99"
sensor_report = rm_cached_variables.report_sensor_error_template.replace(
"{{ Heading }}", "Sensor Offline")
sensor_report = sensor_report.replace("{{ RSMAddressAndPort }}",
rsm_address_port)
data_queue.put([sensor_check, sensor_report, rsm_address_port])
def _system_command_thread(ip, command):
if _login_successful(ip):
get_http_sensor_reading(ip, http_command=command)
def test_sensor_get_commands(self):
sensor_responses = []
for command in sensor_get_commands:
sensor_responses.append(
get_http_sensor_reading(sensor_address,
http_command=command,
timeout=5))
# from routes file system_commands.py
self.assertTrue(sensor_responses[0] == "OK")
self.assertTrue(isinstance(sensor_responses[1], str))
if not check_no_sensor_return(sensor_responses[2],
sensor_get_commands[2]):
self.assertTrue(isinstance(sensor_responses[2], str))
# from routes file text_sensor_readings.py
if not check_no_sensor_return(sensor_responses[3],
sensor_get_commands[3]):
sensor_reading = sensor_responses[3].split(
app_cached_variables.command_data_separator)
self.assertTrue(len(sensor_reading[0].split(",")) > 0)
self.assertTrue(len(sensor_reading[1].split(",")) > 0)
if not check_no_sensor_return(sensor_responses[4],
sensor_get_commands[4]):
sensor_reading = sensor_responses[4].split(
app_cached_variables.command_data_separator)
self.assertTrue(len(sensor_reading[0].split(",")) > 0)
self.assertTrue(len(sensor_reading[1].split(",")) > 0)
if not check_no_sensor_return(sensor_responses[5],
sensor_get_commands[5]):
check_float_reading(sensor_responses[5], sensor_get_commands[5])
self.assertTrue(isinstance(float(sensor_responses[5]), float))
if not check_no_sensor_return(sensor_responses[6],
sensor_get_commands[6]):
check_float_reading(sensor_responses[6], sensor_get_commands[6])
self.assertTrue(isinstance(float(sensor_responses[6]), float))
if not check_no_sensor_return(sensor_responses[7],
sensor_get_commands[7]):
check_float_reading(sensor_responses[7], sensor_get_commands[7])
self.assertTrue(isinstance(float(sensor_responses[7]), float))
if not check_no_sensor_return(sensor_responses[8],
sensor_get_commands[8]):
check_float_reading(sensor_responses[8], sensor_get_commands[8])
self.assertTrue(isinstance(float(sensor_responses[8]), float))
if not check_no_sensor_return(sensor_responses[9],
sensor_get_commands[9]):
check_float_reading(sensor_responses[9], sensor_get_commands[9])
self.assertTrue(isinstance(float(sensor_responses[9]), float))
if not check_no_sensor_return(sensor_responses[10],
sensor_get_commands[10]):
check_float_reading(sensor_responses[10], sensor_get_commands[10])
self.assertTrue(isinstance(float(sensor_responses[10]), float))
if not check_no_sensor_return(sensor_responses[11],
sensor_get_commands[11]):
check_float_reading(sensor_responses[11], sensor_get_commands[11])
self.assertTrue(isinstance(float(sensor_responses[11]), float))
if not check_no_sensor_return(sensor_responses[12],
sensor_get_commands[12]):
sensor_reading = eval(sensor_responses[12])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[13],
sensor_get_commands[13]):
sensor_reading = eval(sensor_responses[13])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[14],
sensor_get_commands[14]):
check_float_reading(sensor_responses[14], sensor_get_commands[14])
self.assertTrue(isinstance(float(sensor_responses[14]), float))
if not check_no_sensor_return(sensor_responses[15],
sensor_get_commands[15]):
sensor_reading = eval(sensor_responses[15])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[16],
sensor_get_commands[16]):
sensor_reading = eval(sensor_responses[16])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[17],
sensor_get_commands[17]):
sensor_reading = eval(sensor_responses[17])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[18],
sensor_get_commands[18]):
sensor_reading = eval(sensor_responses[18])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
if not check_no_sensor_return(sensor_responses[19],
sensor_get_commands[19]):
sensor_reading = eval(sensor_responses[19])
for index, reading in sensor_reading.items():
check_float_reading(reading, str(index))
def _get_sensor_response_time(ip_address):
start_time = time.time()
sensor_check = get_http_sensor_reading(ip_address)
if sensor_check == "OK":
return str(round(time.time() - start_time, 3))
return False
