271 lines
9.4 KiB
Python
271 lines
9.4 KiB
Python
# test common interface
|
|
import datetime
|
|
import json
|
|
import logging
|
|
import os,sys
|
|
import time
|
|
from abc import ABC, abstractmethod
|
|
from pathlib import Path
|
|
from typing import Any, AnyStr, Tuple
|
|
|
|
from leo_grifo_core import theRecorder
|
|
from leo_grifo_pdf2report import PDFClass
|
|
|
|
|
|
#logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.INFO)
|
|
logging.basicConfig(format='%(levelname)s: %(message)s', level=logging.DEBUG)
|
|
|
|
CWD = os.path.dirname(__file__)
|
|
DEF_VERIFICATION_REPORT_FOLDER = os.path.join(CWD,"..","VERIFICATION_REPORTS")
|
|
|
|
class TestCommonNotification:
|
|
def __int__(self):
|
|
self.trap = dict()
|
|
|
|
def set(self, _interface_name, _value, _desc, _uptime):
|
|
self.trap['interface'] = _interface_name
|
|
self.trap['data'] = _value
|
|
self.trap['description'] = _desc
|
|
if _uptime:
|
|
self.trap['time'] = _uptime
|
|
else:
|
|
self.trap['time'] = datetime.datetime.now()
|
|
return self
|
|
|
|
#
|
|
# Common interface for each set/get class
|
|
#
|
|
class TestCommonInterface(ABC):
|
|
def __init__(self, _timeout=0.1):
|
|
self.timeout = _timeout
|
|
|
|
def default_timeout(self):
|
|
return self.timeout
|
|
|
|
def enable_notification(self) -> bool:
|
|
logging.error('This interface has no notification management')
|
|
return False
|
|
|
|
def disable_notification(self) -> bool:
|
|
logging.error('This interface has no notification management')
|
|
return False
|
|
|
|
def get_last_notification(self) -> (Any, AnyStr):
|
|
logging.error('This interface has no notification management')
|
|
return None, 'Notifications not available'
|
|
|
|
@abstractmethod
|
|
def check(self, expected_result, *fields, **kwargs) -> (bool, Any, AnyStr):
|
|
return False, None, None
|
|
|
|
@abstractmethod
|
|
def set(self, value, *fields, **kwargs) -> (bool, AnyStr):
|
|
return True, None
|
|
|
|
@abstractmethod
|
|
def get(self, *fields, **kwargs) -> (Any, AnyStr):
|
|
return None, None
|
|
|
|
def discover(self, *fields, **kwargs) -> list:
|
|
logging.error('This interface has no discover facilities')
|
|
return []
|
|
|
|
#
|
|
# Common function interface for using in test
|
|
#
|
|
def check(equipment_interface: TestCommonInterface, expected_result, *fields, **kwargs) -> (bool, Any):
|
|
asHex = kwargs.get('hex',False)
|
|
expected = None
|
|
error_desc = ''
|
|
|
|
common_desc = 'Check that '+ ' '.join((f'{e}' for e in fields))
|
|
if isinstance(expected_result, (list, tuple)) and len(expected_result) == 2:
|
|
expected_ranges = ( f'0x{v:X}' for v in expected_result ) if asHex is True else expected_result
|
|
if expected_result[0] is None:
|
|
common_desc += ' is less than {} '.format(expected_ranges[1])
|
|
expected = expected_ranges[1]
|
|
elif expected_result[1] is None:
|
|
common_desc += ' is greater than {} '.format(expected_ranges[0])
|
|
expected = expected_ranges[0]
|
|
else:
|
|
common_desc += ' is between {} and {} '.format(expected_ranges[0], expected_ranges[1])
|
|
# expected = ???
|
|
else:
|
|
expected = expected_result
|
|
desc_expected = f'0x{expected_result:X}' if isinstance(expected_result, int ) and asHex is True else expected_result
|
|
common_desc += ' is equal to {}'.format(desc_expected)
|
|
|
|
common_desc += kwargs.get('description', '')
|
|
logging.info(common_desc)
|
|
|
|
try:
|
|
ret, value, error = equipment_interface.check(expected_result,*fields,**kwargs)
|
|
except Exception as e:
|
|
error_desc = 'EXCEPTION: {}'.format(e)
|
|
logging.error(error_desc)
|
|
theRecorder.add_step(common_desc, False, error_desc, '{}'.format(expected))
|
|
return False, None
|
|
|
|
if isinstance(expected_result, int ) and asHex is True:
|
|
desc_value = f'0x{int(value):X}'
|
|
else:
|
|
desc_value = f'{value}'
|
|
|
|
if ret:
|
|
logging.info('OK: read value = {}'.format(desc_value))
|
|
else:
|
|
logging.warning('CHECK ERROR: read value = {}'.format(desc_value))
|
|
error_desc = ' Read value = {} is not the expected result'.format(desc_value)
|
|
if error is not None:
|
|
logging.error('INTERFACE ERROR: {}'.format(error))
|
|
error_desc = error
|
|
|
|
theRecorder.add_step(common_desc, ret, error_desc, desc_value)
|
|
return ret, error_desc
|
|
|
|
|
|
def getValue(equipment_interface: TestCommonInterface, *fields, **kwargs) -> (Any, AnyStr):
|
|
asHex = kwargs.get('hex',False)
|
|
common_desc = 'Get '
|
|
for f in fields:
|
|
common_desc += f'{f} '
|
|
common_desc += kwargs.get('description', '')
|
|
logging.info(common_desc)
|
|
error_desc = ''
|
|
|
|
if kwargs.get('timeout') is None:
|
|
kwargs['timeout'] = equipment_interface.default_timeout()
|
|
try:
|
|
value, error = equipment_interface.get(*fields,**kwargs)
|
|
except Exception as e:
|
|
error_desc = 'EXCEPTION: {}'.format(e)
|
|
logging.error(error_desc)
|
|
theRecorder.add_step(common_desc, False, error_desc, '')
|
|
return None, error_desc
|
|
|
|
ret = True
|
|
if error is not None:
|
|
logging.error('INTERFACE ERROR: {}'.format(error))
|
|
error_desc = error
|
|
ret = False
|
|
|
|
desc_value = f'0x{value:X}' if asHex is True else value
|
|
theRecorder.add_step(common_desc, ret, error_desc, '{} '.format(desc_value))
|
|
return value, error
|
|
|
|
|
|
#NEW SET: gestione in caso l'elemento passato come input_value è volutamente sbagliato
|
|
def setValue(equipment_interface: TestCommonInterface, input_value, *fields, **kwargs) -> (bool, Any):
|
|
common_desc = 'Set '
|
|
for f in fields:
|
|
common_desc += f'{f} '
|
|
common_desc += f'to {input_value}'
|
|
common_desc += kwargs.get('description', '')
|
|
|
|
logging.info(common_desc)
|
|
|
|
if kwargs.get('timeout') is None:
|
|
kwargs['timeout'] = equipment_interface.default_timeout()
|
|
|
|
if kwargs.get('error_case') is None:
|
|
kwargs['error_case'] = False
|
|
|
|
try:
|
|
ret, error = equipment_interface.set(input_value,*fields,**kwargs)
|
|
except Exception as e:
|
|
exception_desc = 'EXCEPTION: {}'.format(e)
|
|
logging.error(exception_desc)
|
|
|
|
if(kwargs.get('error_case',False)==True):
|
|
time.sleep(kwargs.get('timeout', equipment_interface.timeout))
|
|
theRecorder.add_step(common_desc, True, exception_desc, '{}'.format(input_value))#verde
|
|
return True, common_desc
|
|
else:
|
|
theRecorder.add_step(common_desc, False, exception_desc, '{}'.format(input_value))
|
|
time.sleep(kwargs.get('timeout', equipment_interface.timeout))
|
|
return False, None
|
|
|
|
error_desc = ''
|
|
if error is not None:
|
|
logging.error('INTERFACE ERROR: {}'.format(error))
|
|
error_desc = error
|
|
|
|
if(kwargs.get('error_case',False)==True and ret==False):
|
|
ret=True
|
|
|
|
time.sleep(kwargs.get('timeout', equipment_interface.timeout))
|
|
theRecorder.add_step(common_desc, ret, error_desc, '{} '.format(input_value))
|
|
return ret, error_desc
|
|
|
|
|
|
def check_in_range(equipment_interface: TestCommonInterface, expected_range: Tuple, *fields, **kwargs) -> (bool, Any):
|
|
return check(equipment_interface, expected_range, *fields, **kwargs)
|
|
|
|
|
|
def check_greater_than(equipment_interface: TestCommonInterface, lower_range, *fields, **kwargs) -> (bool, Any):
|
|
return check(equipment_interface, (lower_range, None), *fields, **kwargs)
|
|
|
|
|
|
def check_less_than(equipment_interface: TestCommonInterface, upper_range, *fields, **kwargs) -> (bool, Any):
|
|
return check(equipment_interface, (None, upper_range), *fields, **kwargs)
|
|
|
|
|
|
def add_text_log(text):
|
|
theRecorder.add_step(text, True, None, None)
|
|
logging.info(text)
|
|
|
|
def get_json_config():
|
|
config_file = os.path.join(CWD,'json','instrument_settings.json')
|
|
c = open(config_file)
|
|
return json.load(c) if c is not None else {}
|
|
|
|
def record_pass_fail_result(description, result, errors, expected):
|
|
theRecorder.add_step(description, result, errors, expected)
|
|
text = f'FAILED: {description} - expected result was: {expected}'
|
|
if result:
|
|
text = f'PASS: {description}'
|
|
logging.info(text)
|
|
|
|
def generate_pdf_report(template_info_filename, elapsed_time):
|
|
f = open(os.path.join(CWD,'json','default_template.json'))
|
|
t = open(template_info_filename)
|
|
json_template = json.load(f)
|
|
json_test = json.load(t)
|
|
|
|
my_pdf = PDFClass(elapsed_time)
|
|
doc = my_pdf.start_doc(json_template)
|
|
file_name = my_pdf.pdf_name(json_template, '')
|
|
my_pdf.pdf_preamble(doc, json_test)
|
|
my_pdf.pdf_test_information_section(doc, json_test)
|
|
|
|
session = theRecorder.get_db_session()
|
|
if len(session) > 1:
|
|
tot = 0
|
|
ok = 0
|
|
for v in session:
|
|
tot = tot + 1
|
|
if v.test['fail'] == 0:
|
|
ok = ok + 1
|
|
my_pdf.pdf_step_summary(ok, tot - ok, doc)
|
|
|
|
for s in session:
|
|
my_pdf.pdf_step_result(s.test['name'], s.test['pass'], s.test['fail'], doc)
|
|
step_list = theRecorder.get_db()
|
|
my_pdf.pdf_step_execution(step_list[s.idx_first:s.idx_last], doc)
|
|
|
|
folder_path = f"{DEF_VERIFICATION_REPORT_FOLDER}/{json_test['ID']}"
|
|
print(folder_path)
|
|
if not Path(folder_path).is_dir():
|
|
os.makedirs(Path(folder_path))
|
|
|
|
my_pdf.pdf_generate(folder_path, doc, file_name)
|
|
|
|
|
|
def close_session(session_name: str):
|
|
theRecorder.close_session(session_name)
|
|
|
|
|
|
def create_and_enable_notifier(interface_obj: TestCommonInterface):
|
|
theRecorder.add_step('Launch notification receiver ...', True, None, None)
|
|
return interface_obj.enable_notification()
|