wiliot-certificate 1.4.0a2__py3-none-any.whl → 1.5.0a1__py3-none-any.whl

gw_certificate/cert_results.py

@@ -0,0 +1,138 @@
+import os
+import tabulate
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, KeepTogether, Image
+from reportlab.lib.styles import ParagraphStyle
+from reportlab.lib.enums import TA_CENTER, TA_LEFT
+
+# Local imports
+from gw_certificate.ag.ut_defines import TEST_FAILED, TEST_INCONCLUSIVE, TEST_PASSED, TEST_INFO, TEST_WARNING, TEST_OPTIONAL
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+format_timedelta = lambda delta: f"{int(delta.total_seconds()//3600):02}:{int((delta.total_seconds()%3600)//60):02}:{int(delta.total_seconds()%60):02}"
+
+##################################
+# GENERIC
+##################################
+def generate_pdf_results_file(gw_cert):
+    # Extract GW certificate tests results
+    failures, inconclusive = 0, 0
+    for test in gw_cert.tests:
+        if test.rc == TEST_INCONCLUSIVE:
+            inconclusive += 1
+        elif test.rc == TEST_FAILED:
+            failures += 1
+
+    # Generate PDF file
+    doc = SimpleDocTemplate(gw_cert.result_pdf_path, pagesize=letter)
+    doc.title = f"Wiliot Gateway Certificate Results"
+    elements, hdr_page = [], []
+
+    # Add Wiliot Logo
+    img = Image(os.path.join(BASE_DIR, "../common", "wlt_logo.png"), width=100, height=40)  # Adjust size as needed
+    hdr_page.append(img)
+    hdr_page.append(Spacer(1, 20))
+
+    # Title and Summary
+    red_header = STYLES_PDF.get("RED_HEADER", ParagraphStyle("Default"))
+    green_header = STYLES_PDF.get("GREEN_HEADER", ParagraphStyle("Default"))
+    module_header = STYLES_PDF.get("MODULE_HEADER", ParagraphStyle("Default"))
+    test_header = STYLES_PDF.get("TEST_HEADER", ParagraphStyle("Default"))
+    text_style_bold = STYLES_PDF.get("BLACK_BOLD", ParagraphStyle("Default"))
+    if gw_cert.error:
+        title = Paragraph(f"<b>Wiliot Gateway Certificate Error!</b>", red_header)
+        hdr_page.append(title)
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(Paragraph(f"{gw_cert.error}", text_style_bold))
+    else:
+        title = Paragraph(f"<b>Wiliot Gateway Certificate Passed!</b>", green_header) if not failures else Paragraph(f"<b>Wiliot Gateway Certificate Failed!</b>", red_header)
+        hdr_page.append(title)
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(Paragraph(f"<b>Summary</b>", module_header))
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(Paragraph(f"Run date: {gw_cert.current_datetime.strftime('%d/%m/%Y, %H:%M:%S')}", text_style_bold))
+        hdr_page.append(Paragraph(f"Tests duration: {format_timedelta(gw_cert.runtime())}", text_style_bold))
+        hdr_page.append(Paragraph(f"Certificate version: {gw_cert.gw_cert_version}", text_style_bold))
+        hdr_page.append(Paragraph(f"BLE simulator mac: {gw_cert.uart.mac}", text_style_bold))
+        hdr_page.append(Paragraph(f"BLE simulator version: {gw_cert.uart.fw_version}", text_style_bold))
+        hdr_page.append(Paragraph(f"Tested gateway ID: {gw_cert.gw_id}", text_style_bold))
+        hdr_page.append(Spacer(1, 20))
+
+        # Count Table
+        count_data = [
+            ["PASSED", "INCONCLUSIVE", "FAILED", "TOTAL"],
+            [len(gw_cert.tests)-(failures+inconclusive), inconclusive, failures, len(gw_cert.tests)]
+        ]
+        count_table = Table(count_data)
+        count_table.setStyle(INNER_TABLE_STYLE)
+        hdr_page.append(count_table)
+        hdr_page.append(Spacer(1, 20))
+
+        # Test Results
+        summary_data = []
+        text_style_center = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
+        text_style_left = STYLES_PDF.get("BLACK_LEFT", ParagraphStyle("Default"))
+        for test in gw_cert.tests:
+            summary_data += [[test, pass_or_fail_pdf(test), format_timedelta(test.duration)]]
+            elements.append(Paragraph(f"<b>{test.test_name}</b>", module_header))
+            elements.append(Spacer(1, 20))
+            elements.append(pass_or_fail_pdf(test))
+            elements.append(Spacer(1, 10))
+            elements.append(Paragraph(f"Test duration: {format_timedelta(test.duration)}", text_style_bold))
+            elements.append(Spacer(1, 10))
+            inner_table, stages_breakdown = [["Phase", "Result", "Duration"]], []
+            for stage in test.stages:
+                stages_breakdown += [KeepTogether([Paragraph(stage.stage_name, test_header), Spacer(1, 10), pass_or_fail_pdf(stage), Spacer(1, 10)]
+                                                + [Paragraph(l, text_style_left) for l in stage.report.split('\n')]
+                                                + [Spacer(1, 10)])]
+                inner_table += [[Paragraph(stage.stage_name, text_style_center), pass_or_fail_pdf(stage), Paragraph(format_timedelta(stage.duration), text_style_center)]]
+            test_table = Table(inner_table)
+            test_table.setStyle(INNER_TABLE_STYLE)
+            elements.append(test_table)
+            elements.append(Spacer(1, 20))
+            elements += stages_breakdown
+            elements.append(PageBreak())
+        summary_table = Table([["Name", "Result", "Duration"]] + summary_data)
+        summary_table.setStyle(INNER_TABLE_STYLE)
+        elements = hdr_page + [summary_table, PageBreak()] + elements
+
+    doc.build(elements)
+
+
+##################################
+# PDF
+##################################
+STYLES_PDF = {
+    "GREEN_HEADER": ParagraphStyle("Green Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.green, alignment=TA_CENTER),
+    "RED_HEADER": ParagraphStyle("Red Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.red, alignment=TA_CENTER),
+    "MODULE_HEADER": ParagraphStyle("Module Header", fontName="Helvetica-Bold", fontSize=16, textColor=colors.navy, alignment=TA_CENTER),
+    "TEST_HEADER": ParagraphStyle("Test Header", fontName="Helvetica-Bold", fontSize=12, textColor=colors.black, alignment=TA_CENTER),
+    "BLACK": ParagraphStyle("Black", fontName="Helvetica", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_CENTER, wordWrap = 'CJK'),
+    "BLACK_LEFT": ParagraphStyle("Black Left", fontName="Helvetica", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
+    "BLACK_BOLD": ParagraphStyle("Black Bold", fontName="Helvetica-Bold", fontSize=9, textColor=colors.black, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
+    "BLUE": ParagraphStyle("Blue", fontName="Helvetica-Bold", fontSize=9, textColor=colors.navy, splitLongWords=False, alignment=TA_CENTER),
+    "CYAN": ParagraphStyle("Cyan", fontName="Helvetica-Bold", fontSize=9, textColor=colors.cyan, splitLongWords=False, alignment=TA_CENTER),
+    "GREEN": ParagraphStyle("Green", fontName="Helvetica-Bold", fontSize=9, textColor=colors.green, splitLongWords=False, alignment=TA_CENTER),
+    "WARNING": ParagraphStyle("Warning", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gold, splitLongWords=False, alignment=TA_CENTER),
+    "RED": ParagraphStyle("Red", fontName="Helvetica-Bold", fontSize=9, textColor=colors.red, splitLongWords=False, alignment=TA_CENTER),
+    "GRAY": ParagraphStyle("Gray", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gray, splitLongWords=False, alignment=TA_CENTER),
+}
+def color_pdf(c, t):
+    style = STYLES_PDF.get(c, ParagraphStyle("Default"))
+    return Paragraph(t, style)
+pdf_result_map = {TEST_FAILED: color_pdf("RED", "FAILED"), TEST_INCONCLUSIVE: color_pdf("WARNING", "INCONCLUSIVE"), 
+                  TEST_PASSED: color_pdf("GREEN", "PASSED"),  TEST_INFO: color_pdf("CYAN", "INFO"),
+                  TEST_WARNING: color_pdf("WARNING", "WARNING"), TEST_OPTIONAL: color_pdf("GRAY", "OPTIONAL")}
+pass_or_fail_pdf = lambda obj : pdf_result_map[obj.rc]
+
+INNER_TABLE_STYLE = TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 9),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.whitesmoke),
+                ('WORDWRAP', (0, 0), (-1, -1), False),
+            ])

gw_certificate/gw_certificate.py

@@ -20,6 +20,7 @@ from gw_certificate.tests import *
 from gw_certificate.interface.uart_ports import get_uart_ports
 from gw_certificate.api_if.gw_capabilities import GWCapabilities
 from gw_certificate.tests import TESTS_NO_UART
+import gw_certificate.cert_results as cert_results
 
 GW_CERT_VERSION = importlib.metadata.version("wiliot-certificate")
 
@@ -45,14 +46,16 @@ class GWCertificate:
                  aggregation_time=0, env='prod'):
         # Runtime
         self.env_dirs = WiliotDir()
-        self.current_datetime = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
-        self.certificate_dir = os.path.join(self.env_dirs.get_wiliot_root_app_dir(), 'gw-certificate', self.current_datetime)
+        self.current_datetime = datetime.datetime.now()
+        self.duration = None
+        self.certificate_dir = os.path.join(self.env_dirs.get_wiliot_root_app_dir(), 'gw-certificate', self.current_datetime.strftime('%Y%m%d_%H%M%S'))
         self.env_dirs.create_dir(self.certificate_dir)
         self.logger_filename = initialize_logger(self.certificate_dir)
         self.logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}.log')
         self.mqtt_logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}_mqtt.log')
         self.sniffer_logger_filepath = os.path.join(self.certificate_dir, f'{self.logger_filename}_sniffer.log')
-        self.result_html_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime}.html')
+        self.result_html_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime.strftime('%Y%m%d_%H%M%S')}.html')
+        self.result_pdf_path = os.path.join(self.certificate_dir, f'results_{self.current_datetime.strftime('%Y%m%d_%H%M%S')}.pdf')
         self.template_engine = TemplateEngine()
         self.env = env
 
@@ -68,6 +71,7 @@ class GWCertificate:
         self.stress_pps = stress_pps
         self.aggregation_time = aggregation_time
         self.actions = actions
+        self.error = ""
         
         # UART-related. Require only when running tests that need it
         self.use_uart = not all(test in TESTS_NO_UART for test in tests)
@@ -76,7 +80,9 @@ class GWCertificate:
             self.uart_comports = get_uart_ports()
             debug_print(f'UART Ports:{self.uart_comports}')
             if len(self.uart_comports) < 1:
-                raise GWCertificateError('A Wiliot certification kit must be connected to USB!')
+                self.error = "A Wiliot certification kit must be connected to USB!"
+                cert_results.generate_pdf_results_file(self)
+                raise GWCertificateError(self.error)
         
             for port in self.uart_comports:
                 try:
@@ -85,13 +91,19 @@ class GWCertificate:
                 except UARTError as e:
                     debug_print(f'Port: {port} - {e}')
             if type(self.uart) is not UARTInterface:
-                raise GWCertificateError("Cannot initialize any port!")
+                self.error = "Cannot initialize any port!"
+                cert_results.generate_pdf_results_file(self)
+                raise GWCertificateError(self.error)
             self.ble_sim = BLESimulator(self.uart)
             self.sniffer = BLESniffer(self.uart, logger_filepath=self.sniffer_logger_filepath)
         
         # Tests
         self.tests = [t(**self.__dict__) for t in tests]
         debug_print(f'Running Tests: {self.tests}')
+
+    def runtime(self):
+        datetime.timedelta
+        return datetime.datetime.now() - self.current_datetime
     
     def run_tests(self):
         debug_print("Sleeping 20 seconds after mqtt connect")
@@ -125,11 +137,13 @@ class GWCertificate:
                                                     sniffer_log = sniffer_log,
                                                     gw_id = self.gw_id,
                                                     version = self.gw_cert_version,
-                                                    datetime = self.current_datetime)
+                                                    datetime = self.current_datetime.strftime('%Y%m%d_%H%M%S'))
         with open(self.result_html_path, 'w', encoding="utf-8") as f:
             f.write(html)
+        cert_results.generate_pdf_results_file(self)
         debug_print("Test Finished. Results HTML Saved: " + self.result_html_path)
         webbrowser.open('file://' + os.path.realpath(self.result_html_path))
+        webbrowser.open('file://' + os.path.realpath(self.result_pdf_path))
 
 if __name__ == "__main__":
     from api_secrets import *

gw_certificate/interface/mqtt.py

@@ -216,6 +216,7 @@ class MqttClient:
                 "gatewayId": gw_id,
                 "imageDirUrl": image_dir_url,
                 "versionUUID": version_uuid,
+                "upgradeBlSd": upgrade_bl_sd,
                 "txPacket": reboot_packet,
                 "txMaxRetries": tx_max_duration // 100,
                 "txMaxDurationMs": tx_max_duration,

gw_certificate/tests/actions.py

@@ -248,7 +248,6 @@ class ActionsTest(GenericTest):
     
     def run(self):
         super().run()
-        self.test_pass = PERFECT_SCORE
         for stage in self.stages:
             stage.prepare_stage()
             stage.run()

gw_certificate/tests/connection.py

@@ -182,5 +182,5 @@ class ConnectionTest(GenericTest):
         for stage in self.stages:
             stage.prepare_stage()
             stage.run()
-            self.test_pass = PassCriteria.calc_for_test(self, stage)
             self.add_to_test_report(stage.generate_stage_report())
+            self.test_pass = PassCriteria.calc_for_test(self, stage)

gw_certificate/tests/generic.py

@@ -7,6 +7,7 @@ from gw_certificate.common.debug import debug_print
 from gw_certificate.api_if.gw_capabilities import GWCapabilities
 from gw_certificate.interface.ble_simulator import BLESimulator
 from gw_certificate.interface.mqtt import MqttClient
+from gw_certificate.ag.ut_defines import TEST_PASSED, TEST_FAILED, TEST_INCONCLUSIVE, TEST_OPTIONAL, TEST_WARNING, TEST_INFO
 
 PASS_STATUS = {True: 'PASS', False: 'FAIL'}
 
@@ -37,19 +38,6 @@ class PassCriteria():
             return 'Inconclusive'
         else:
             return 'Fail'
-
-    @staticmethod
-    def missing_score(pass_value:int) -> int:
-        return PERFECT_SCORE - pass_value
-
-    @staticmethod
-    def calc_for_stage_uplink(pass_value:int, stage_name:str) -> int:
-        error_msg = "Insufficient amount of packets were scanned & uploaded by the gateway"
-        return pass_value, error_msg
-
-    @staticmethod
-    def calc_for_stage_stress(pass_value: int, stage_name:str) -> int:
-        return pass_value
     
     @staticmethod
     def calc_for_stage_downlink(rsquared, slope, stage_name:str):
@@ -99,12 +87,14 @@ class GenericTest:
         self.pass_min = PASS_MINIMUM
         self.inconclusive_min = INCONCLUSIVE_MINIMUM
         self.start_time = None
+        self.duration = None
         self.test_name = test_name
         self.test_dir = os.path.join(self.certificate_dir, self.test_name)
         self.env_dirs.create_dir(self.test_dir)
         self.stages = []
         self.test_tooltip = kwargs.get('test_tooltip', 'Missing tooltip')
         self.result_indication = kwargs.get('result_indication', SCORE_BASED)
+        self.rc = TEST_PASSED
         
     def __repr__(self):
         return self.test_name
@@ -125,8 +115,12 @@ class GenericTest:
     def create_test_html(self):
         self.report_html = self.template_engine.render_template('test.html', test=self,
                                                                 running_time = self.runtime())
-    
+
     def end_test(self):
+        self.determine_rc()
+        for stage in self.stages:
+            stage.determine_rc()
+        self.duration = self.runtime()
         self.create_test_html()
 
     def score_pass(self):
@@ -143,6 +137,21 @@ class GenericTest:
         if self.test_pass < self.inconclusive_min:
             return True
         return False
+    
+    def determine_rc(self):
+        # Set test rc - defaults to TEST_PASSED (rc=0)
+        if self.result_indication == 'info':
+            if self.score_pass():
+                self.rc = TEST_INFO
+            else:
+                self.rc = TEST_WARNING
+        elif self.result_indication == 'optional':
+            self.rc = TEST_OPTIONAL
+        else:
+            if self.score_inconclusive():
+                self.rc = TEST_INCONCLUSIVE
+            elif self.score_fail():
+                self.rc = TEST_FAILED
 
 
 class GenericStage():
@@ -156,9 +165,11 @@ class GenericStage():
         self.report = ''
         self.report_html = ''
         self.start_time = None
+        self.duration = None
         self.csv_path = os.path.join(self.test_dir, f'{self.stage_name}.csv')
         self.stage_tooltip = kwargs.get('stage_tooltip', 'Missing tooltip')
         self.error_summary = kwargs.get('error_summary', ERR_SUMMARY_DEFAULT)
+        self.rc = TEST_PASSED
         
     def __repr__(self):
         return self.stage_name
@@ -180,11 +191,14 @@ class GenericStage():
     
     def add_report_header(self):
         uncapitalize = lambda s: s[:1].lower() + s[1:] if s else ''
-        self.add_to_stage_report(f'Stage run time: {datetime.datetime.now() - self.start_time}')
+        self.duration = datetime.datetime.now() - self.start_time
+        self.add_to_stage_report(f'Stage run time: {self.duration}')
         self.add_to_stage_report(f'This stage {uncapitalize(self.stage_tooltip)}.')
         self.add_report_line_separator()
     
     def add_report_topic_validation(self, topic:Literal['status', 'data']):
+        pass
+        # Pass until validated
         if self.topic_suffix != '':
             return
         valid_topic, invalid_msg, invalid_topic = self.mqttc.validate_serialization_topic(topic)
@@ -192,7 +206,7 @@ class GenericStage():
             # For now not failing stage since the customBroker command include topics explicitly
             # self.stage_pass = MINIMUM_SCORE
             # self.error_summary += "Invalid serialization-topic combination. "
-            self.add_to_stage_report(f'Warning: Received message on {invalid_topic} although serialization is {self.mqttc.get_serialization()}')
+            self.add_to_stage_report(f'Note: Received message on {invalid_topic} although serialization is {self.mqttc.get_serialization()}')
     
     def score_pass(self):
         if self.stage_pass >= self.pass_min:
@@ -208,4 +222,16 @@ class GenericStage():
         if self.stage_pass < self.inconclusive_min:
             return True
         return False
-        
+            
+    def determine_rc(self):
+        # Set stage rc - defaults to TEST_PASSED (rc=0)
+        if self.result_indication == 'info':
+            if self.score_pass():
+                self.rc = TEST_INFO
+            else:
+                self.rc = TEST_WARNING
+        else:
+            if self.score_inconclusive():
+                self.rc = TEST_INCONCLUSIVE
+            elif self.score_fail():
+                self.rc = TEST_FAILED

{wiliot_certificate-1.4.0a2.dist-info → wiliot_certificate-1.5.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: wiliot_certificate
-Version: 1.4.0a2
+Version: 1.5.0a1
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License: MIT License
@@ -93,11 +93,13 @@ Increments time delays between packets to evaluate GW's capability in handling i
 #### GW Certificate Release Notes:
 1.4.0:
  - Released in a standalone wiliot-certificate package
- - Python 3.12 support
+ - Python 3.13 support
  - Gw API version 205 support
- - Registration Test
+ - Registration test added
+ - Bridge OTA stage added under actions
  - Aggregation flag supported by StressTest
-
+ - -update flag compatibility fix. Upgrades bootloader as well
+ - -actions flag to select specific actions to test
 
 ```
 usage: wlt-gw-certificate [-h] -owner OWNER -gw GW [-suffix SUFFIX] [-tests {connection,uplink,downlink,stress}]