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

brg_certificate/wltPb_pb2.pyi

@@ -62,6 +62,28 @@ class UplinkMessage(_message.Message):
     actionStatus: ActionStatus
     def __init__(self, gatewayStatus: _Optional[_Union[GatewayStatus, _Mapping]] = ..., gatewayInfo: _Optional[_Union[GatewayInfo, _Mapping]] = ..., gatewayLogs: _Optional[_Union[GatewayLogs, _Mapping]] = ..., actionStatus: _Optional[_Union[ActionStatus, _Mapping]] = ...) -> None: ...
 
+class ACL(_message.Message):
+    __slots__ = ("mode_allow", "ids")
+    MODE_ALLOW_FIELD_NUMBER: _ClassVar[int]
+    IDS_FIELD_NUMBER: _ClassVar[int]
+    mode_allow: bool
+    ids: _containers.RepeatedScalarFieldContainer[bytes]
+    def __init__(self, mode_allow: bool = ..., ids: _Optional[_Iterable[bytes]] = ...) -> None: ...
+
+class GatewayConfigValue(_message.Message):
+    __slots__ = ("integerValue", "numberValue", "stringValue", "boolValue", "aclValue")
+    INTEGERVALUE_FIELD_NUMBER: _ClassVar[int]
+    NUMBERVALUE_FIELD_NUMBER: _ClassVar[int]
+    STRINGVALUE_FIELD_NUMBER: _ClassVar[int]
+    BOOLVALUE_FIELD_NUMBER: _ClassVar[int]
+    ACLVALUE_FIELD_NUMBER: _ClassVar[int]
+    integerValue: int
+    numberValue: float
+    stringValue: str
+    boolValue: bool
+    aclValue: ACL
+    def __init__(self, integerValue: _Optional[int] = ..., numberValue: _Optional[float] = ..., stringValue: _Optional[str] = ..., boolValue: bool = ..., aclValue: _Optional[_Union[ACL, _Mapping]] = ...) -> None: ...
+
 class GatewayStatus(_message.Message):
     __slots__ = ("gatewayId", "gatewayType", "downlinkSupported", "bridgeOtaUpgradeSupported", "apiVersion", "version", "bleSwVersion", "interfaceSwVersion", "location", "config", "bleAddress")
     class ConfigEntry(_message.Message):
@@ -69,8 +91,8 @@ class GatewayStatus(_message.Message):
         KEY_FIELD_NUMBER: _ClassVar[int]
         VALUE_FIELD_NUMBER: _ClassVar[int]
         key: str
-        value: Value
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+        value: GatewayConfigValue
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
     GATEWAYID_FIELD_NUMBER: _ClassVar[int]
     GATEWAYTYPE_FIELD_NUMBER: _ClassVar[int]
     DOWNLINKSUPPORTED_FIELD_NUMBER: _ClassVar[int]
@@ -91,9 +113,9 @@ class GatewayStatus(_message.Message):
     bleSwVersion: str
     interfaceSwVersion: str
     location: Location
-    config: _containers.MessageMap[str, Value]
+    config: _containers.MessageMap[str, GatewayConfigValue]
     bleAddress: str
-    def __init__(self, gatewayId: _Optional[str] = ..., gatewayType: _Optional[str] = ..., downlinkSupported: bool = ..., bridgeOtaUpgradeSupported: bool = ..., apiVersion: _Optional[int] = ..., version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, Value]] = ..., bleAddress: _Optional[str] = ...) -> None: ...
+    def __init__(self, gatewayId: _Optional[str] = ..., gatewayType: _Optional[str] = ..., downlinkSupported: bool = ..., bridgeOtaUpgradeSupported: bool = ..., apiVersion: _Optional[int] = ..., version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, GatewayConfigValue]] = ..., bleAddress: _Optional[str] = ...) -> None: ...
 
 class GatewayInfo(_message.Message):
     __slots__ = ("entries",)
@@ -115,28 +137,32 @@ class GatewayLogs(_message.Message):
     def __init__(self, logs: _Optional[_Iterable[str]] = ...) -> None: ...
 
 class ActionStatus(_message.Message):
-    __slots__ = ("action", "status")
+    __slots__ = ("action", "status", "step", "progress", "bridgeId")
     ACTION_FIELD_NUMBER: _ClassVar[int]
     STATUS_FIELD_NUMBER: _ClassVar[int]
+    STEP_FIELD_NUMBER: _ClassVar[int]
+    PROGRESS_FIELD_NUMBER: _ClassVar[int]
+    BRIDGEID_FIELD_NUMBER: _ClassVar[int]
     action: int
     status: int
-    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ...) -> None: ...
+    step: int
+    progress: int
+    bridgeId: bytes
+    def __init__(self, action: _Optional[int] = ..., status: _Optional[int] = ..., step: _Optional[int] = ..., progress: _Optional[int] = ..., bridgeId: _Optional[bytes] = ...) -> None: ...
 
 class DownlinkMessage(_message.Message):
-    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "customBroker", "customMessage")
+    __slots__ = ("txPacket", "gatewayAction", "bridgeUpgrade", "gatewayConfig", "customMessage")
     TXPACKET_FIELD_NUMBER: _ClassVar[int]
     GATEWAYACTION_FIELD_NUMBER: _ClassVar[int]
     BRIDGEUPGRADE_FIELD_NUMBER: _ClassVar[int]
     GATEWAYCONFIG_FIELD_NUMBER: _ClassVar[int]
-    CUSTOMBROKER_FIELD_NUMBER: _ClassVar[int]
     CUSTOMMESSAGE_FIELD_NUMBER: _ClassVar[int]
     txPacket: TxPacket
     gatewayAction: GatewayAction
     bridgeUpgrade: BridgeUpgrade
     gatewayConfig: GatewayConfig
-    customBroker: CustomBroker
     customMessage: CustomMessage
-    def __init__(self, txPacket: _Optional[_Union[TxPacket, _Mapping]] = ..., gatewayAction: _Optional[_Union[GatewayAction, _Mapping]] = ..., bridgeUpgrade: _Optional[_Union[BridgeUpgrade, _Mapping]] = ..., gatewayConfig: _Optional[_Union[GatewayConfig, _Mapping]] = ..., customBroker: _Optional[_Union[CustomBroker, _Mapping]] = ..., customMessage: _Optional[_Union[CustomMessage, _Mapping]] = ...) -> None: ...
+    def __init__(self, txPacket: _Optional[_Union[TxPacket, _Mapping]] = ..., gatewayAction: _Optional[_Union[GatewayAction, _Mapping]] = ..., bridgeUpgrade: _Optional[_Union[BridgeUpgrade, _Mapping]] = ..., gatewayConfig: _Optional[_Union[GatewayConfig, _Mapping]] = ..., customMessage: _Optional[_Union[CustomMessage, _Mapping]] = ...) -> None: ...
 
 class TxPacket(_message.Message):
     __slots__ = ("payload", "maxRetries", "maxDurationMs")
@@ -179,8 +205,8 @@ class GatewayConfig(_message.Message):
         KEY_FIELD_NUMBER: _ClassVar[int]
         VALUE_FIELD_NUMBER: _ClassVar[int]
         key: str
-        value: Value
-        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[Value, _Mapping]] = ...) -> None: ...
+        value: GatewayConfigValue
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[_Union[GatewayConfigValue, _Mapping]] = ...) -> None: ...
     VERSION_FIELD_NUMBER: _ClassVar[int]
     BLESWVERSION_FIELD_NUMBER: _ClassVar[int]
     INTERFACESWVERSION_FIELD_NUMBER: _ClassVar[int]
@@ -190,28 +216,8 @@ class GatewayConfig(_message.Message):
     bleSwVersion: str
     interfaceSwVersion: str
     location: Location
-    config: _containers.MessageMap[str, Value]
-    def __init__(self, version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, Value]] = ...) -> None: ...
-
-class CustomBroker(_message.Message):
-    __slots__ = ("customBroker", "port", "brokerUrl", "username", "password", "updateTopic", "statusTopic", "dataTopic")
-    CUSTOMBROKER_FIELD_NUMBER: _ClassVar[int]
-    PORT_FIELD_NUMBER: _ClassVar[int]
-    BROKERURL_FIELD_NUMBER: _ClassVar[int]
-    USERNAME_FIELD_NUMBER: _ClassVar[int]
-    PASSWORD_FIELD_NUMBER: _ClassVar[int]
-    UPDATETOPIC_FIELD_NUMBER: _ClassVar[int]
-    STATUSTOPIC_FIELD_NUMBER: _ClassVar[int]
-    DATATOPIC_FIELD_NUMBER: _ClassVar[int]
-    customBroker: bool
-    port: int
-    brokerUrl: str
-    username: str
-    password: str
-    updateTopic: str
-    statusTopic: str
-    dataTopic: str
-    def __init__(self, customBroker: bool = ..., port: _Optional[int] = ..., brokerUrl: _Optional[str] = ..., username: _Optional[str] = ..., password: _Optional[str] = ..., updateTopic: _Optional[str] = ..., statusTopic: _Optional[str] = ..., dataTopic: _Optional[str] = ...) -> None: ...
+    config: _containers.MessageMap[str, GatewayConfigValue]
+    def __init__(self, version: _Optional[str] = ..., bleSwVersion: _Optional[str] = ..., interfaceSwVersion: _Optional[str] = ..., location: _Optional[_Union[Location, _Mapping]] = ..., config: _Optional[_Mapping[str, GatewayConfigValue]] = ...) -> None: ...
 
 class CustomMessage(_message.Message):
     __slots__ = ("entries",)

brg_certificate/wlt_types.py

@@ -92,16 +92,11 @@ class WltPkt():
                 self.pkt = ag.UnifiedEchoPktV1()
             elif self.data_hdr.group_id_major == ag.GROUP_ID_BLE5_EXTENDED: 
                 self.pkt = ag.UnifiedEchoExtPkt()
-            else:
-                print(f"Unidentified unified group id found: {hex(self.data_hdr.group_id_major)}")
         # SideInfo pkts
         elif self.hdr.group_id == ag.GROUP_ID_SIDE_INFO_SENSOR:
             self.pkt = ag.SideInfoSensor()
         elif self.hdr.group_id == ag.GROUP_ID_SIDE_INFO:
             self.pkt = ag.SideInfo()
-        else:
-            print(f"Unidentified sensor group id found: {hex(self.data_hdr.group_id_major)}")
-
         if self.pkt:
             if self.data_hdr.group_id_major == ag.GROUP_ID_BLE5_EXTENDED:
                 self.pkt.set(string[14:84])
@@ -111,4 +106,7 @@ class WltPkt():
         elif self.hdr.group_id == ag.GROUP_ID_SIGNAL_INDICATOR:
             self.pkt = eval_pkt(f'SignalIndicatorDataV{ag.SIGNAL_INDICATOR_PACKET_VERSION_LATEST}')(string[8:62])
         elif self.hdr.uuid_lsb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB and self.hdr.uuid_msb == ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB:
-            self.pkt = ag.SensorData(string)
+            self.pkt = ag.SensorData(string)
+        # Unparsed pkts
+        else:
+            print(f"Unable to parse packet with payload: {string}")

gw_certificate/ag/ut_defines.py

@@ -164,9 +164,12 @@ GLOBAL_PACING_GROUP_THRESHOLD =                     0.70
 PACKETS_ECHO_OFF =                                  16
 TEST_PASSED =                                       0
 TEST_FAILED =                                       -1
+TEST_INCONCLUSIVE =                                 1
+TEST_INFO =                                         2
+TEST_WARNING =                                      3
+TEST_OPTIONAL =                                     4
 NO_RESPONSE =                                       "NO_RESPONSE"
 DONE =                                              "DONE"
-TEST_SUCCESS =                                      ":)"
 MGMT_PKT =                                          "mgmt_pkt"
 UNIFIED_PKT =                                       "unified_pkt"
 SIDE_INFO_PKT =                                     "side_info_pkt"

gw_certificate/cert_results.py

@@ -0,0 +1,145 @@
+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"))
+    text_style_centered = STYLES_PDF.get("BLACK", 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("<u>Run Info:</u>", text_style_bold))
+        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(Spacer(1, 10))
+        if gw_cert.use_uart:
+            hdr_page.append(Paragraph("<u>Certification Kit Info:</u>", 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(Spacer(1, 10))
+        hdr_page.append(Paragraph("<u>Tested Device Info:</u>", 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 += [[Paragraph(f'<a href="#{test}">{test}</a>', text_style_centered), pass_or_fail_pdf(test), format_timedelta(test.duration)]]
+            elements.append(Paragraph(f"<a name='{test}'/><b>{test}</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,8 @@ 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!"
+                raise GWCertificateError(self.error)
         
             for port in self.uart_comports:
                 try:
@@ -85,13 +90,18 @@ 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!"
+                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 +135,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/gw_certificate_cli.py

@@ -27,8 +27,8 @@ def filter_actions(actions_names):
 def main():
     usage = (
         "usage: wlt-gw-certificate [-h] -owner OWNER -gw GW\n"
-        f"                          [-tests {{connection, uplink, downlink, stress}}] [-update] [-pps {STRESS_DEFAULT_PPS}]\n"
-        "                           [-agg AGG] [-env {prod, test, dev}] [-no-reboot]"
+        f"                          [-tests {{connection, uplink, downlink, actions, stress}}] [-update] [-pps {STRESS_DEFAULT_PPS}]\n"
+        f"                          [-actions {{info, reboot, bridgeota}}] [-agg AGG] [-env {{prod, test, dev}}]"
         )
 
     parser = ArgumentParser(prog='wlt-gw-certificate',
@@ -43,7 +43,7 @@ def main():
                           help="Tests to run. Registration omitted by default.", required=False, nargs='+',
                           default=['connection', 'uplink', 'downlink', 'actions', 'stress'])
     optional.add_argument('-actions', type=str, choices=['info', 'reboot', 'bridgeota'],
-                          help="Action stages to run under ActionsTest", required=False, nargs='+', default=['info', 'reboot', 'ota'])
+                          help="Action stages to run under ActionsTest", required=False, nargs='+', default=['info', 'reboot', 'bridgeota'])
     optional.add_argument('-update', action='store_true', help='Update test board firmware', default=False, required=False)
     optional.add_argument('-pps', type=int, help='Single packets-per-second rate to simulate in the stress test',
                           choices=STRESS_DEFAULT_PPS, default=None, required=False)

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/interface/uart_if.py

@@ -167,7 +167,7 @@ class UARTInterface:
     def check_fw_supported(self):
         hex_version = version.parse(os.path.splitext(os.path.basename(LATEST_VERSION_PATH))[0].split('_')[0])
         if self.fw_version >= hex_version:
-            debug_print(f'GW Running version {self.fw_version}')
+            debug_print(f'Certification kit version {self.fw_version}')
             return True
         return False
     

gw_certificate/tests/actions.py

@@ -128,7 +128,7 @@ class BridgeOTAStage(GenericActionsStage):
     def __init__(self, **kwargs):
         super().__init__(**kwargs, stage_name=type(self).__name__)
         self.stage_tooltip = "Issues a bridge OTA action to the gateway. Expects it to upgrade the bridge"
-        self.error_summary = "The target bridge was not upgraded"
+        self.error_summary = "Bridge wasn't upgraded."
         self.action = "Bridge Upgrade"
 
         OTA_VERSIONS_TO_USE = ("4.4.52", "4.4.53")
@@ -195,6 +195,7 @@ class BridgeOTAStage(GenericActionsStage):
 
         # Calculate whether stage pass/failed
         if self.action_status is None or self.status_code != 0:
+            debug_print("Failed to receive an actionStatus message.")
             self.stage_pass = MINIMUM_SCORE
             self.add_to_stage_report(f"The bridge OTA test failed")
             if self.action_status is None:
@@ -204,17 +205,22 @@ class BridgeOTAStage(GenericActionsStage):
             elif self.status_code != 0:
                 self.add_to_stage_report(f"Uploaded actionStatus status value received is {self.status_code}.")
             if self.current_version == self.desired_version:
+                debug_print("Bridge was upgraded successfully")
+                self.error_summary = "Failed to receive actionStatus message."
                 self.add_to_stage_report(f"Note that the bridge was actually upgraded successfully.")
+                self.add_to_stage_report(f"Reboot packet received {(self.reboot_packet_ts - self.start_time).total_seconds():.1f}s after start.")
             self.add_to_stage_report(f"{GW_BRIDGE_OTA_DOC}")
         else:
             if self.current_version == self.desired_version:
                 self.stage_pass = PERFECT_SCORE
+                debug_print("Bridge was upgraded successfully, actionStatus message received")
                 self.add_to_stage_report(f"Bridge was upgraded and an actionStatus message was received from the gateway.")
                 self.add_to_stage_report(f"Action status received {(self.action_status_ts - self.start_time).total_seconds():.1f}s after start.")
                 self.add_to_stage_report(f"Reboot packet received {(self.reboot_packet_ts - self.start_time).total_seconds():.1f}s after start.")
                 self.add_to_stage_report(f"Action status received {(self.action_status_ts - self.reboot_packet_ts).total_seconds():.1f}s after reboot.")
             else:
                 self.stage_pass = MINIMUM_SCORE
+                debug_print("Bridge failed to upgrade")
                 self.add_to_stage_report(f"The bridge OTA test failed")
                 self.add_to_stage_report(f"Uploaded actionStatus message indicated success although the bridge was not upgraded.")
 
@@ -248,7 +254,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

gw_certificate/tests/registration.py

@@ -66,6 +66,7 @@ class GenericRegistrationStage(GenericStage):
         debug_print(f"Kick response:{response}")
     
     def validate_kong_logs(self, endpoint:Literal['device-authorize', 'registry', 'token', 'refresh']):
+        message = None
         try:
             message = self.edge.get_kong_logs(self.gw_id)
         except WiliotCloudError as wce:
@@ -78,7 +79,7 @@ class GenericRegistrationStage(GenericStage):
                 return False
             elif status_code == None:
                 raise wce
-        if message.get('status_code') != 200:
+        if isinstance(message, dict) and message.get('status_code') != 200:
             debug_print(f"Failed fetching logs, status_code:{message.get('status_code')}")
             return False