wiliot-certificate 1.5.0a1__py3-none-any.whl → 1.5.2a1__py3-none-any.whl

brg_certificate/cert_mqtt.py

@@ -171,6 +171,8 @@ def on_message_protobuf(mqttc, userdata, message):
         pb_msg_dict = MessageToDict(pb_msg)
         # Align formats with JSON (bytes to hex strings)
         if 'status' in message.topic:
+            if ACTION_STATUS in pb_msg_dict:
+                pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
             if GW_STATUS in pb_msg_dict and ACL_IDS in pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE]:
                 ids_list = pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE][ACL_IDS]
                 for idx, id in enumerate(ids_list):
@@ -285,7 +287,7 @@ def get_undecrypted_data_pkts_count(mqttc):
             undecrypted += p.body_ex['undecrypted']
     return undecrypted
 
-def get_all_sensor_pkts(mqttc, test, is_embedded=False):
+def get_all_sensor_pkts(test, is_embedded=False):
     all_sensor_pkts = couple_sensor_data_si_coupling(test)
     all_sensor_pkts = [p for p in all_sensor_pkts if test.active_brg.id_str == p[BRIDGE_ID] and (p[IS_EMBEDDED] == is_embedded)]
     return all_sensor_pkts
@@ -337,16 +339,17 @@ def count_pkt_id_duplications(test, all_sensor_data_pkts, all_sensor_side_info_p
         coupled_pkt[PKT_ID_CTR] = pkt_ids.count(_pkt_id)
         if coupled_pkt[PKT_ID_CTR] > SENSORS_DATA_SI_DUP:
             print(f"pkt_id {_pkt_id:08X}: {coupled_pkt[PKT_ID_CTR]} occurrences")
-            test.reason = f'Warning: {coupled_pkt[PKT_ID_CTR]} sensor data and si with pkt id 0x{_pkt_id:08X}'
+            #TODO: logging print(debug)
+            # test.reason = f'Warning: {coupled_pkt[PKT_ID_CTR]} sensor data and si with pkt id 0x{_pkt_id:08X}'
 
-def get_all_brg1_ext_sensor_pkts(mqttc, test=None):
+def get_all_brg1_ext_sensor_pkts(test=None):
     test.active_brg = test.brg1
-    pkts = get_all_sensor_pkts(mqttc, test)
+    pkts = get_all_sensor_pkts(test)
     test.active_brg = test.brg0
     return pkts
 
-def get_all_custom_pkts(mqttc, test=None):
-    return get_all_sensor_pkts(mqttc, test, is_embedded=True)
+def get_all_custom_pkts(test=None):
+    return get_all_sensor_pkts(test, is_embedded=True)
 
 def get_all_mgmt_pkts(mqttc):
     all_data_pkts = get_all_data_pkts(mqttc)

brg_certificate/cert_prints.py

@@ -22,6 +22,7 @@ color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
+SEP2 = '\n' + '#'*100 + '\n' + '#'*100 + '\n'
 WIL_CERT_TEXT = r'''
  __        _____ _     ___ ___ _____    ____ _____ ____ _____ ___ _____ ___ ____    _  _____ _____ 
  \ \      / /_ _| |   |_ _/ _ \_   _|  / ___| ____|  _ \_   _|_ _|  ___|_ _/ ___|  / \|_   _| ____|
@@ -65,17 +66,23 @@ def mqtt_scan_wait(test, duration):
         i += 1
     print("\n")
 
+def mqtt_scan_n_create_log_file(test, duration, phase):
+    test.mqttc.flush_pkts()
+    mqtt_scan_wait(test, duration=duration)
+    generate_log_file(test, phase)
+
 def print_update_wait(secs=1):
     sys.stdout.write(".")
     sys.stdout.flush()
     time.sleep(secs)
 
 def field_functionality_pass_fail_print(test, field, value=""):
-    print_string = "{}={}".format(field, value)
+    print_string = f"{field}={value}"
     if value == "":
         print_string = str(field)
     if test.rc == TEST_FAILED:
         utPrint(print_string + " functionality failed!", "RED")
+        utPrint(test.reason, "RED")
     elif test.rc == TEST_SKIPPED:
         utPrint(print_string + " functionality skipped!", "WARNING")
     else:
@@ -127,6 +134,12 @@ def functionality_run_print(func):
     cert_mqtt.write_to_mqtt_log_file(txt)
     cert_data_sim.write_to_data_sim_log_file(txt)
 
+def phase_run_print(func):
+    txt = f"{SEP2}==>> Phase {func}{SEP2}\n"
+    utPrint(txt, "CYAN")
+    cert_mqtt.write_to_mqtt_log_file(txt)
+    cert_data_sim.write_to_data_sim_log_file(txt)
+
 
 def generate_print_string(fields_and_values):
     list_to_print = []

brg_certificate/cert_protobuf.py

@@ -36,19 +36,19 @@ def gw_cfg_pb(msg: dict):
         pb_msg.gatewayConfig.bleSwVersion = msg[BLE_VERSION]
 
     for key, val in msg[ADDITIONAL].items():
-        # Skip GW_MODE since it doesn't exist today and harm the parsing in PB
-        if GW_MODE == key:
+        # Skip GW_MODE since it doesn't exist today and harm the parsing in PB, and skip lat & lng to create duplicate values
+        if key == GW_MODE or key == LAT or key == LNG:
             continue
         pb_value = wpb.GatewayConfigValue()
-        if isinstance(val, int):
+        if type(val) is int:
             pb_value.integerValue = val
-        elif isinstance(val, float):
+        elif type(val) is float:
             pb_value.numberValue = val
-        elif isinstance(val, str):
+        elif type(val) is str:
             pb_value.stringValue = val
-        elif isinstance(val, bool):
+        elif type(val) is bool:
             pb_value.boolValue = val
-        elif isinstance(val, dict) and key == ACL:
+        elif type(val) is dict and key == ACL:
             pb_value.aclValue.mode_allow = ACL_DENY_VALUE if msg[ADDITIONAL][ACL][ACL_MODE] == ACL_DENY else ACL_ALLOW_VALUE
             ids_bytes = [bytes.fromhex(id) for id in msg[ADDITIONAL][ACL][ACL_BRIDGE_IDS]]
             pb_value.aclValue.ids.extend(ids_bytes)

brg_certificate/cert_results.py

@@ -1,32 +1,58 @@
 import os
 import tabulate
 import subprocess
+import datetime
 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
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
 
 # Local imports
 import brg_certificate.cert_utils as cert_utils
 import brg_certificate.cert_prints as cert_prints
-from brg_certificate.cert_defines import BASE_DIR
-from brg_certificate.cert_defines import CERT_VERSION, TEST_FAILED, TEST_SKIPPED, TEST_PASSED, TEST_INIT, UT_RESULT_FILE_HTML, UT_RESULT_FILE_PDF
+from brg_certificate.wlt_types import *
+from brg_certificate.cert_defines import *
 
 
 ##################################
 # GENERIC
 ##################################
+# Defines
+WLT_CERT_HEADLINE =                "Wiliot Certificate Results"
+WLT_CERT_PASS_HEADLINE =           "Wiliot Certificate Passed!"
+WLT_CERT_FAIL_HEADLINE =           "Wiliot Certificate Failed!"
+WLT_CERT_ERROR_HEADLINE =          "Wiliot Certificate Error!"
+SUMMARY_HEADLINE =                 "Summary"
+RUN_INFO =                         "Run Information"
+RUN_DATETIME =                     "Run Time & Date"
+RUN_DUR =                          "Run Duration"
+CERT_VER =                         "Certificate Version"
+TESTING_DEVICE_INFO =              "Testing Device Information"
+TESTED_DEVICE_INFO =               "Tested Device Information"
+SIM =                              "Simulator"
+BRG =                              "Bridge"
+BLE_MAC_ADDRESS =                  "BLE MAC Address"
+BOARD_TYPE =                       "Board Type"
+BLE_VER =                          "BLE Version"
+SUP_API_VER =                      "Supported API Version"
+
 result_map = {TEST_FAILED: cert_prints.color("RED", "FAIL"), TEST_SKIPPED: cert_prints.color("WARNING", "SKIPPED"),
               TEST_PASSED: cert_prints.color("GREEN", "PASS"), TEST_INIT: cert_prints.color("CYAN", "INIT")}
 pass_or_fail = lambda obj : result_map[obj.rc]
+param_name_to_title = lambda s : ' '.join(word.lower().capitalize() for word in s.split('_')).replace('2 4', '2.4') if '_' in s else s
+
 class TestResult:
-    def __init__(self, name="", devices_to_print="", test_table=None, result=None, duration=0):
+    def __init__(self, name="", devices_to_print="", test_table=None, result=None, duration=0, purpose="", kb_link="", compliance="", test_skipped=False):
         self.name = name
         self.devices = devices_to_print
         self.result = result
         self.test_table = test_table
         self.duration = duration
+        self.purpose = purpose
+        self.kb_link = kb_link
+        self.compliance = compliance
+        self.test_skipped = test_skipped
     
     def __repr__(self):
         return self.name
@@ -74,7 +100,7 @@ def get_update_status_from_log_file(log_file="update_log.txt"):
                     break
     return update_status
 
-def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_time=0, duration=0, brg='', brg_version='', gw_ble_version = '', gw_ble_mac='', tests=[], error=None, pipeline=False):
+def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_time=datetime.datetime.now(), duration=0, brg=None, internal_brg=None, tests=[], error=None, pipeline=False):
     # Generate HTML file
     if html:
         f = open(os.path.join(BASE_DIR, UT_RESULT_FILE_HTML), "w", encoding="utf-8")
@@ -85,39 +111,38 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
                                 stdout=subprocess.PIPE, shell=True, cwd=os.environ['BITBUCKET_CLONE_DIR'])
             output, err = p.communicate()
         if error:
-            f.write("<br><h1 style='color:#ab0000'>Wiliot Certificate Error!</h1><br>")
+            f.write(f"<br><h1 style='color:#ab0000'>{WLT_CERT_ERROR_HEADLINE}</h1><br>")
             if pipeline:
                 f.write("<hr>" + output.decode("utf-8") + "<br>")
                 f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/commits/{}'>Commit page on bitbucket</a><hr>".format(os.environ['BITBUCKET_COMMIT']))
             f.write(update_status + "<br><br>")
             f.write(error + "<br><br>")
-            f.write("Run duration: {} <br><br>".format(str(duration).split(".")[0]))
-            if brg_version:
-                f.write("Bridge version: {} <br><br>".format(brg_version))
+            f.write(f"{RUN_DUR}: {str(duration).split(".")[0]} <br><br>")
+            if brg:
+                f.write(f"{BRG} {BLE_VER}: {brg.version} <br><br>")
         elif tests:
             if not failures and ("successfully!" in update_status or "skipped!" in update_status or not pipeline):
-                f.write("<br><h1 style='color:#00AB83'>Wiliot Certificate Passed!</h1>")
+                f.write(f"<br><h1 style='color:#00AB83'>{WLT_CERT_PASS_HEADLINE}</h1>")
             else:
-                f.write("<br><h1 style='color:#ab0000'>Wiliot Certificate Failed!</h1>")
+                f.write(f"<br><h1 style='color:#ab0000'>{WLT_CERT_FAIL_HEADLINE}</h1>")
             if pipeline:
                 f.write("<hr>" + output.decode("utf-8") + "<br>")
                 f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/commits/{}'>Commit page on bitbucket</a><hr>".format(os.environ['BITBUCKET_COMMIT']))
                 f.write(update_status + "<br><br>")
-            f.write("Run date: {} <br><br>".format(start_time.strftime('%d/%m/%Y, %H:%M:%S')))
-            f.write("Tests duration: {} <br><br>".format(str(duration).split(".")[0]))
-            f.write("Certificate version: {} <br><br>".format(CERT_VERSION))
-            if gw_ble_mac:
-                f.write("BLE simulator mac: {} <br><br>".format(gw_ble_mac))
-            if gw_ble_version:
-                f.write("BLE simulator version: {} <br><br>".format(gw_ble_version))
-            f.write("Tested bridge ID: {} <br><br>".format(brg))
-            if brg_version:
-                f.write("Bridge version: {} <br><br>".format(brg_version))
+            f.write(f"{RUN_DATETIME}: {start_time.strftime('%d/%m/%Y, %H:%M:%S')} <br><br>")
+            f.write(f"{RUN_DUR}: {str(duration).split(".")[0]} <br><br>")
+            f.write(f"{CERT_VER}: {CERT_VERSION} <br><br>")
+            if internal_brg:
+                f.write(f"{SIM} {BLE_MAC_ADDRESS}: {internal_brg.id_str} <br><br>")
+                f.write(f"{SIM} {BLE_VER}: {internal_brg.version} <br><br>")
+            if brg:
+                f.write(f"{BRG} {BLE_MAC_ADDRESS}: {brg.id_str} <br><br>")
+                f.write(f"{BRG} {BLE_VER}: {brg.version} <br><br>")
             f.write(tabulate.tabulate([[len(tests)-(failures+skipped), skipped, failures, len(tests)]], headers=["PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="html"))
             f.write(generate_tests_table(tests, html=True))
             f.write("<br><br>")
         if pipeline:
-            f.write("<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/pipelines/results/{}'>Build's page and artifacts on bitbucket</a></p><br><br>".format(os.environ['BITBUCKET_BUILD_NUMBER']))
+            f.write(f"<p><a href='https://bitbucket.org/wiliot/wiliot-nordic-firmware/pipelines/results/{os.environ['BITBUCKET_BUILD_NUMBER']}'>Build's page and artifacts on bitbucket</a></p><br><br>")
         f.write("<img src='https://www.wiliot.com/src/img/svg/logo.svg' width='100' height='40' alt='Wiliot logo'>")
         f.write(HTML_END)
         f.close()
@@ -135,31 +160,42 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
 
         # Title and Summary
         red_header = STYLES_PDF.get("RED_HEADER", ParagraphStyle("Default"))
-        green_header = STYLES_PDF.get("GREEN_HEADER", ParagraphStyle("Default"))
+        black_header = STYLES_PDF.get("BLACK_HEADER", ParagraphStyle("Default"))
         module_header = STYLES_PDF.get("MODULE_HEADER", ParagraphStyle("Default"))
-        test_header = STYLES_PDF.get("TEST_HEADER", ParagraphStyle("Default"))
-        text_style = STYLES_PDF.get("BLACK_BOLD", ParagraphStyle("Default"))
+        test_header = STYLES_PDF.get("TEST_LINK_HEADER", ParagraphStyle("Default"))
+        test_purpose = STYLES_PDF.get("TEST_HEADER", ParagraphStyle("Default"))
+        bold_text_style = STYLES_PDF.get("BLACK_BOLD", ParagraphStyle("Default"))
+        bold_right_text_style = STYLES_PDF.get("BLUE_BOLD_RIGHT", ParagraphStyle("Default"))
+        centered_text_style = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
         if error:
-            title = Paragraph("<b>Wiliot Certificate Error!</b>", red_header)
+            title = Paragraph(f"<b>{WLT_CERT_ERROR_HEADLINE}</b>", red_header)
             hdr_page.append(title)
             hdr_page.append(Spacer(1, 20))
-            hdr_page.append(Paragraph(f"{error}", text_style))
+            hdr_page.append(Paragraph(f"{error}", bold_text_style))
         else:
-            title = Paragraph("<b>Wiliot Certificate Passed!</b>", green_header) if not failures else Paragraph("<b>Wiliot Certificate Failed!</b>", red_header)
+            title = Paragraph(f"<b>{WLT_CERT_HEADLINE}</b>", black_header)
             hdr_page.append(title)
         hdr_page.append(Spacer(1, 20))
-        hdr_page.append(Paragraph(f"<b>Summary</b>", module_header))
+        hdr_page.append(Paragraph(f"<a name='{SUMMARY_HEADLINE}'/><b>{SUMMARY_HEADLINE}</b>", module_header))
         hdr_page.append(Spacer(1, 20))
-        hdr_page.append(Paragraph(f"Run date: {start_time.strftime('%d/%m/%Y, %H:%M:%S')}", text_style))
-        hdr_page.append(Paragraph(f"Tests duration: {str(duration).split('.')[0]}", text_style))
-        hdr_page.append(Paragraph(f"Certificate version: {CERT_VERSION}", text_style))
-        if gw_ble_mac:
-            hdr_page.append(Paragraph(f"BLE simulator mac: {gw_ble_mac}", text_style))
-        if gw_ble_version:
-            hdr_page.append(Paragraph(f"BLE simulator version: {gw_ble_version}", text_style))
-        hdr_page.append(Paragraph(f"Tested bridge ID: {brg}", text_style))
-        if brg_version:
-            hdr_page.append(Paragraph(f"Tested bridge version: {brg_version}", text_style))
+        hdr_page.append(Paragraph(f"<u>{RUN_INFO}:</u>", bold_text_style))
+        hdr_page.append(Paragraph(f"{RUN_DATETIME}: {start_time.strftime('%d/%m/%Y, %H:%M:%S')}", bold_text_style))
+        hdr_page.append(Paragraph(f"{RUN_DUR}: {str(duration).split('.')[0]}", bold_text_style))
+        hdr_page.append(Paragraph(f"{CERT_VER}: {CERT_VERSION}", bold_text_style))
+        hdr_page.append(Spacer(1, 10))
+        if brg:
+            hdr_page.append(Paragraph(f"<u>{TESTED_DEVICE_INFO}:</u>", bold_text_style))
+            hdr_page.append(Paragraph(f"{BRG} {BLE_MAC_ADDRESS}: {brg.id_str}", bold_text_style))
+            hdr_page.append(Paragraph(f"{BRG} {BOARD_TYPE}: {ag.BOARD_TYPES_LIST[brg.board_type]}", bold_text_style))
+            hdr_page.append(Paragraph(f"{BRG} {BLE_VER}: {brg.version}", bold_text_style))
+            hdr_page.append(Paragraph(f"{BRG} {SUP_API_VER}: {brg.api_version}", bold_text_style))
+            hdr_page.append(Spacer(1, 10))
+        if internal_brg:
+            hdr_page.append(Paragraph(f"<u>{TESTING_DEVICE_INFO}:</u>", bold_text_style))
+            hdr_page.append(Paragraph(f"{SIM} {BLE_MAC_ADDRESS}: {internal_brg.id_str}", bold_text_style))
+            hdr_page.append(Paragraph(f"{SIM} {BOARD_TYPE}: {ag.BOARD_TYPES_LIST[internal_brg.board_type]}", bold_text_style))
+            hdr_page.append(Paragraph(f"{SIM} {BLE_VER}: {internal_brg.version}", bold_text_style))
+            hdr_page.append(Paragraph(f"{SIM} {SUP_API_VER}: {internal_brg.api_version}", bold_text_style))
         hdr_page.append(Spacer(1, 20))
 
         # Count Table
@@ -168,7 +204,7 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
             [len(tests)-(failures+skipped), skipped, failures, len(tests)]
         ]
         count_table = Table(count_data)
-        count_table.setStyle(INNER_TABLE_STYLE)
+        count_table.setStyle(inner_table_style('CENTER'))
         hdr_page.append(count_table)
         hdr_page.append(Spacer(1, 20))
 
@@ -176,27 +212,35 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
         results_per_module = generate_results_per_module_for_pdf(tests=tests)
         summary_data = []
         for module, test_results in results_per_module.items():
-            elements.append(Paragraph(f"<b>{module + ' Module' if module else 'Edge Management'}</b>", module_header))
-            elements.append(Spacer(1, 20))
+            module_objects = []
+            module_skipped = True # Remains True if all tests are skipped
+            module_objects.append(Paragraph(f"<b>{module + ' Module' if not 'Edge' in module else module}</b>", module_header))
+            module_objects.append(Spacer(1, 20))
             for test_result in test_results:
-                group = []
-                summary_data += [[module, test_result.name, test_result.result, test_result.duration]]
-                group.append(Paragraph(f"<b>{test_result.name}</b>", test_header))
-                group.append(Spacer(1, 10))
-
-                group.append(test_result.result)
-                group.append(Spacer(1, 10))
-
-                group.append(Paragraph(f"Tested Devices: {test_result.devices}", text_style))
-                group.append(Paragraph(f"Test duration: {test_result.duration}", text_style))
-                group.append(Spacer(1, 10))
-
-                group.append(test_result.test_table)
-                group.append(Spacer(1, 20))
-                elements.append(KeepTogether(group))
-            elements.append(PageBreak())
-        summary_table = Table([["Module", "Name", "Result", "Duration"]] + summary_data)
-        summary_table.setStyle(INNER_TABLE_STYLE)
+                test_objects = []
+                name = Paragraph(f'<a href="#{module}_{test_result.name}">{test_result.name}</a>', centered_text_style) if not test_result.test_skipped else test_result.name
+                summary_data += [[module, name, test_result.result, test_result.compliance]]
+                test_objects.append(Paragraph(f'<a name="{module}_{test_result.name}"/><a href="{test_result.kb_link}">{test_result.name}</a>', test_header))
+                test_objects.append(Spacer(1, 10))
+                test_objects.append(test_result.result)
+                test_objects.append(Spacer(1, 10))
+                test_objects.append(Paragraph(test_result.purpose, test_purpose))
+                test_objects.append(Spacer(1, 10))
+                if not test_result.test_skipped:
+                    module_skipped = False # Set to False if at least one test isn't skipped
+                    test_objects.append(Paragraph(f"Tested devices: {test_result.devices}", bold_text_style))
+                    test_objects.append(Paragraph(f"Test duration: {test_result.duration}", bold_text_style))
+                    test_objects.append(Spacer(1, 10))
+                    test_objects.append(test_result.test_table)
+                    test_objects.append(Spacer(1, 10))
+                    test_objects.append(Paragraph(f"<a href='#{SUMMARY_HEADLINE}'>Back to {SUMMARY_HEADLINE}</a>", bold_right_text_style))
+                    test_objects.append(Spacer(1, 20))
+                module_objects.append(KeepTogether(test_objects))
+            if not module_skipped:
+                elements += module_objects
+                elements.append(PageBreak())
+        summary_table = Table([["Module", "Name", "Result", "Compliance"]] + summary_data)
+        summary_table.setStyle(inner_table_style('LEFT'))
         elements = hdr_page + [summary_table, PageBreak()] + elements
 
         doc.build(elements)
@@ -279,17 +323,19 @@ HTML_END = """
 # PDF
 ##################################
 STYLES_PDF = {
-    "GREEN_HEADER": ParagraphStyle("Green Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.green, alignment=TA_CENTER),
+    "BLACK_HEADER": ParagraphStyle("Black Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.black, 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'),
+    "TEST_HEADER": ParagraphStyle("Test Header", fontName="Helvetica-Bold", fontSize=12, textColor=colors.black, alignment=TA_LEFT),
+    "TEST_LINK_HEADER": ParagraphStyle('Test Link Header', fontName="Helvetica-Bold", fontSize=14, textColor=colors.blue, alignment=TA_LEFT),
+    "BLACK": ParagraphStyle("Black", 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_BOLD_RIGHT": ParagraphStyle("Black Bold", fontName="Helvetica-Bold", fontSize=9, textColor=colors.blue, splitLongWords=False, alignment=TA_RIGHT, 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),
+    "CYAN": ParagraphStyle("Cyan", fontName="Helvetica-Bold", fontSize=9, textColor=colors.cyan, splitLongWords=False, alignment=TA_LEFT),
+    "GREEN": ParagraphStyle("Green", fontName="Helvetica-Bold", fontSize=9, textColor=colors.green, splitLongWords=False, alignment=TA_LEFT),
+    "WARNING": ParagraphStyle("Warning", fontName="Helvetica-Bold", fontSize=9, textColor=colors.gold, splitLongWords=False, alignment=TA_LEFT),
+    "RED": ParagraphStyle("Red", fontName="Helvetica-Bold", fontSize=9, textColor=colors.red, splitLongWords=False, alignment=TA_LEFT),
 }
 def color_pdf(c, t):
     style = STYLES_PDF.get(c, ParagraphStyle("Default"))
@@ -298,31 +344,32 @@ pdf_result_map = {TEST_FAILED: color_pdf("RED", "FAILED"), TEST_SKIPPED: color_p
                   TEST_PASSED: color_pdf("GREEN", "PASSED"),  TEST_INIT: color_pdf("CYAN", "INIT")}
 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),
-            ])
+inner_table_style = lambda align :  TableStyle([
+                                    ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+                                    ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+                                    ('ALIGN', (0, 0), (-1, -1), f'{align}'),
+                                    ('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),
+                                ])
 
 def generate_results_per_module_for_pdf(tests=[]):
     text_style = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
     results_per_module = {}
     for test in tests:
-        name=test.module_name if (not test.internal_brg or "gw" in test.module_name) else f"{test.module_name} (internal brg)"
         devices_to_print = (test.gw if not test.brg0 or test.gw_only else
                         (f"{test.brg0.id_str}\n{test.brg1.id_str}" if test.brg1 and test.multi_brg else test.brg0.id_str))
-        inner_table = [[Paragraph(phase.name, text_style), pass_or_fail_pdf(phase), Paragraph(phase.reason, text_style)] for phase in test.phases]
+        inner_table = [[Paragraph(param_name_to_title(phase.name), text_style), pass_or_fail_pdf(phase), Paragraph(phase.reason, text_style)] for phase in test.phases]
         test_table = Table([["Phase", "Result", "Notes"]] + inner_table)
-        test_table.setStyle(INNER_TABLE_STYLE)
-        test_result = TestResult(name=name, devices_to_print=devices_to_print,
-                                 test_table=test_table, result=pass_or_fail_pdf(test), duration=test.duration)
-        module_name = cert_utils.module2name(test.test_module)
+        test_table.setStyle(inner_table_style('LEFT'))
+        compliance = "Mandatory" if test.test_json[MANDATORY] else "Optional"
+        test_result = TestResult(name=test.test_json[NAME], devices_to_print=devices_to_print, test_table=test_table, result=pass_or_fail_pdf(test),
+                                 duration=test.duration, purpose=str(test.test_json[PURPOSE]), compliance=compliance,
+                                 kb_link=test.test_json[DOCUMENTATION], test_skipped=(test.rc == TEST_SKIPPED))
+        module_name = test.test_json[MODULE]
         if module_name not in results_per_module:
                 results_per_module[module_name] = [test_result]
         else:

brg_certificate/cert_utils.py

@@ -43,20 +43,25 @@ def load_module(module_name, module_path, rel_path="."):
 def handle_error(error, start_time):
     utPrint(error, "red")
     duration = (datetime.datetime.now()-start_time)
-    cert_results.generate_results_files(html=True, pdf=True, start_time=start_time, duration=duration, error=error, pipeline=cert_common.pipeline_running())
+    cert_results.generate_results_files(html=True, pdf=False, start_time=start_time, duration=duration, error=error, pipeline=cert_common.pipeline_running())
     sys.exit(-1)
 
 ##################################
 # Test
 ##################################
 class WltTest:
-    def __init__(self, line, gw, mqttc, brg0=None, brg1=None, exit_on_param_failure=False, gw_lan=False,
+    def __init__(self, line, gw, mqttc, sim_mqttc=None, brg0=None, brg1=None, exit_on_param_failure=False, gw_lan=False,
                  gw_orig_versions={}, server=PROD, latest=False, release_candidate=False, private_setup=False,
                  internal_brg_obj=None, gw_sim='', data='', port='', protobuf=False):
         if line:
             test_list_line = line.strip().split()
             self.name = test_list_line[0]
-            self.test_module = TEST_MODULES_MAP[self.name.split('/')[0]] if self.name.split('/')[0] in TEST_MODULES_MAP else ag.MODULE_EMPTY
+            self.test_module = ag.MODULE_EMPTY # Default test module
+            # Determine test's module
+            for s in self.name.split('/'):
+                if s in TEST_MODULES_MAP:
+                    self.test_module = TEST_MODULES_MAP[s]
+                    break
             line_params = test_list_line[1:]
             self.dir = os.path.join("tests", self.name)
             self.module_name = os.path.join(os.path.basename(self.name))
@@ -88,6 +93,7 @@ class WltTest:
         self.end_time = None
         self.duration = None
         self.mqttc = mqttc
+        self.sim_mqttc = sim_mqttc
         self.rtsa = ""
         self.exit_on_param_failure = exit_on_param_failure
         self.rand = random.randrange(255)
@@ -268,9 +274,9 @@ def handle_prep_brg_for_latest(test, interface, start_time):
 def ut_prep_brg(args, mqttc, start_time, gw, brg, gw_server, protobuf):
     brg = Bridge(brg)
     utPrint(SEP)
-    if not args.port:
+    if not cert_common.is_cert_running:
         versions_mgmt = load_module('versions_mgmt.py', f'{UTILS_BASE_REL_PATH}/versions_mgmt.py')
-        brg_owner = versions_mgmt.gw_brg_owner(env="aws", server="prod", brg=brg.id_str)
+        brg_owner = versions_mgmt.gw_brg_owner(env=AWS, server=PROD, brg=brg.id_str)
         if brg_owner and not brg_owner in r_codes:
             print_warn(f"BRG {brg.id_str} owned by account {brg_owner}")
     test = WltTest("", gw, mqttc, brg0=brg, gw_lan=args.lan, server=gw_server, exit_on_param_failure=args.exit_on_param_failure,
@@ -320,10 +326,10 @@ def get_gw_id(gw):
     else:
         return gw
 
-def ut_prep_gw(args, mqttc, start_time):
+def ut_prep_gw(args, mqttc, start_time, tester_gw=False):
     # Check GW is online and configure to defaults
     utPrint(SEP)
-    gw = args.gw
+    gw = args.brg_cloud_connectivity if args.brg_cloud_connectivity and not tester_gw else args.gw
     test = WltTest("", gw, mqttc, gw_lan=args.lan)
     utPrint(f"Getting GW {gw} Information", "BLUE")
     response = cert_common.get_gw_info(test)

brg_certificate/certificate_bcc_sanity_test_list.txt

@@ -0,0 +1,40 @@
+# The certificate should run for every bridge change
+# The setup will include 1 tested BRG with cloud connectivity + 1 GW connected with UART or remotely
+# Run command example with COM PORT connection:
+# python brg_certificate_cli.py --gw SIM --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_sanity_test_list.txt --data sim --port <COM_PORT>
+# Run command example with remote GW connection:
+# python brg_certificate_cli.py --gw <GWYYYYYYYYYYYY> --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_sanity_test_list.txt --data sim
+
+# ------------- edge_mgmt -------------
+edge_mgmt/periodic_msgs_test
+edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
+
+# ------------- energy2400 -------------
+energy2400/pattern_test ENERGY_PATTERN_2_4_CHANNEL_37 ENERGY_PATTERN_2_4_CHANNEL_39 ENERGY_PATTERN_2_4_FREQ_2454
+energy2400/output_power_test -12 0 3
+energy2400/duty_cycle_test 1 50 75
+energy2400/signal_indicator_test internal_brg brg0_rxtx_brg1_rxtx
+
+# ------------- energy_sub1g -------------
+energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
+energy_sub1g/duty_cycle_test 15 20 40 0
+energy_sub1g/signal_indicator_test 60,4
+
+# ------------- datapath -------------
+datapath/rssi_threshold_test -80
+datapath/pattern_test DATAPATH_PATTERN_38_38_39 DATAPATH_PATTERN_EU_PATTERN
+datapath/output_power_test -12 0 3
+datapath/pkt_filter_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/pkt_filter_gen3_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/pkt_filter_ble5_test PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT
+datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
+datapath/aging_test low_pacer
+datapath/num_of_tags_test 500
+
+# ------------- calibration -------------
+calibration/output_power_test -12 0 3
+calibration/interval_test 1 25 50
+calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_DISABLE_BEACON
+
+# ------------- sensors -------------
+sensors/ext_sensor_test tag_data_only rssi_threshold snsr0_scrmbl_snsr1_no_scrmbl

brg_certificate/certificate_bcc_test_list.txt

@@ -0,0 +1,50 @@
+# The certificate should run for every bridge change
+# The setup will include 1 tested BRG with cloud connectivity + 1 GW connected with UART or remotely
+# Run command example with COM PORT connection:
+# python brg_certificate_cli.py --gw SIM --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt --data sim --port <COM_PORT>
+# Run command example with remote GW connection:
+# python brg_certificate_cli.py --gw <GWYYYYYYYYYYYY> --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt --data sim
+
+# ------------- edge_mgmt -------------
+edge_mgmt/periodic_msgs_test
+edge_mgmt/actions_test ACTION_GW_HB ACTION_BLINK ACTION_SEND_HB ACTION_GET_BATTERY_SENSOR ACTION_GET_POF_DATA ACTION_PL_STATUS ACTION_GET_MODULE ACTION_REBOOT ACTION_RESTORE_DEFAULTS
+
+# ------------- energy2400 -------------
+energy2400/pattern_test ENERGY_PATTERN_2_4_NO_ENERGIZING ENERGY_PATTERN_2_4_CHANNEL_37 ENERGY_PATTERN_2_4_CHANNEL_38 ENERGY_PATTERN_2_4_CHANNEL_39 ENERGY_PATTERN_2_4_FREQ_2450 ENERGY_PATTERN_2_4_FREQ_2454
+energy2400/output_power_test -12 -8 -4 0 2 3
+energy2400/duty_cycle_test 1 25 50 75
+energy2400/signal_indicator_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_500k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none
+energy2400/signal_indicator_ble5_10_250k_test internal_brg rssi_threshold brg0_rx_brg1_tx brg0_none_brg1_rx brg0_rxtx_brg1_rxtx brg0_tx_brg1_none 
+
+# ------------- energy_sub1g -------------
+energy_sub1g/pattern_test SUB1G_ENERGY_PATTERN_NO_ENERGIZING SUB1G_ENERGY_PATTERN_SINGLE_TONE_915000 SUB1G_ENERGY_PATTERN_FCC_HOPPING SUB1G_ENERGY_PATTERN_SINGLE_TONE_917500 SUB1G_ENERGY_PATTERN_NZ_HOPPING
+energy_sub1g/duty_cycle_test 15 20 40 0
+energy_sub1g/signal_indicator_test 60,4 100,3
+
+# ------------- datapath -------------
+datapath/rssi_threshold_test -80 -65 -10
+datapath/pattern_test DATAPATH_PATTERN_38_38_39 DATAPATH_PATTERN_EU_PATTERN
+datapath/output_power_test -12 -8 -4 0 2 3
+datapath/pacer_interval_test 5 15 30 60
+datapath/pacer_interval_ble5_test 5 15 30 60
+datapath/pkt_filter_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS PKT_FILTER_TEMP_ADVANCED_AND_DEBUG_PKTS
+datapath/pkt_filter_gen3_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS
+datapath/pkt_filter_ble5_test PKT_FILTER_RANDOM_FIRST_ARRIVING_PKT PKT_FILTER_DISABLE_FORWARDING PKT_FILTER_TEMP_PKT PKT_FILTER_ADVANCED_PKT PKT_FILTER_TEMP_AND_ADVANCED_PKTS
+datapath/rx_channel_test RX_CHANNEL_37 RX_CHANNEL_38 RX_CHANNEL_39 RX_CHANNEL_10_250K RX_CHANNEL_10_500K
+datapath/rx_rate_gen2_test mid_values diff_pacer min_value max_value  diff_rate
+datapath/rx_rate_gen3_test mid_values diff_pacer min_value max_value  diff_rate
+datapath/pacer_interval_tags_count_test 1 10 15 30
+datapath/aging_test low_pacer high_pacer
+datapath/num_of_tags_test 5000
+
+# ------------- pwr_mgmt -------------
+pwr_mgmt/pwr_mgmt_test
+
+# ------------- calibration -------------
+calibration/output_power_test -12 -8 -4 0 2 3
+calibration/interval_test 1 25 50
+calibration/pattern_test CALIBRATION_PATTERN_38_38_39 CALIBRATION_PATTERN_STANDARD CALIBRATION_PATTERN_EU_PATTERN CALIBRATION_PATTERN_DISABLE_BEACON
+
+# ------------- sensors -------------
+sensors/ext_sensor_test tag_data_only rssi_threshold snsr0_no_scrmbl snsr1_scrmbl snsr0_scrmbl_snsr1_no_scrmbl snsr0_scrmbl_snsr1_scrmbl