wiliot-certificate 4.4.3__py3-none-any.whl → 4.5.0a1__py3-none-any.whl

{brg_certificate → certificate}/cert_prints.py

@@ -1,9 +1,7 @@
-from brg_certificate.cert_defines import *
+from certificate.cert_defines import *
 import time, datetime
 import sys
 import json
-import brg_certificate.cert_mqtt as cert_mqtt
-import brg_certificate.cert_data_sim as cert_data_sim
 import os
 import re
 
@@ -33,7 +31,14 @@ WIL_CERT_TEXT = r'''
 '''
 
 hex_str2int = lambda s : int(s, 16)
-print_brg = lambda brg: brg.__dict__ if brg else None
+
+def write_to_log_file(file, txt, mode):
+    file_path = os.path.join(ARTIFACTS_DIR, file)
+    if not os.path.exists(os.path.dirname(file_path)):
+        os.makedirs(os.path.dirname(file_path))
+    f = open(file_path, mode)
+    f.write(txt)
+    f.close()
 
 def print_pkt(p):
     print(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"))
@@ -43,12 +48,16 @@ def print_warn(txt):
     if txt:
         utPrint(f"WARNING: {txt}","WARNING")
 
-def mqtt_scan_start(test, duration):
-    utPrint("Scanning mqtt packets on {} for {} seconds...".format(test.gw, duration), "WARNING")
+def mqtt_scan_start(test, duration, target=DUT):
+    gw = test.dut if target == DUT else test.tester
+    utPrint("Scanning mqtt packets on {} for {} seconds...".format(gw.id_str, duration), "WARNING")
     sys.stdout.flush()
 
-def mqtt_scan_wait(test, duration):
-    utPrint("Scanning mqtt packets on {} for {} seconds...".format(test.gw, duration), "WARNING")
+
+def mqtt_scan_wait(test, duration, target=DUT):
+    mqttc = test.get_mqttc_by_target(target)
+    gw = test.dut if target == DUT else test.tester
+    utPrint("Scanning mqtt packets on {} for {} seconds...".format(gw.id_str, duration), "WARNING")
     sys.stdout.flush()
     chars = ["|", "/", "-", "\\"]
     start_time = datetime.datetime.now()
@@ -60,22 +69,26 @@ def mqtt_scan_wait(test, duration):
         if pipeline_running():
             sys.stdout.write(".")
         else:
-            sys.stdout.write("\r"+chars[i%4]*20+" "+str(cur_duration)+" "+chars[i%4]*20+" {} pkts captured".format(len(test.mqttc._userdata["pkts"].data)))
+            sys.stdout.write("\r"+chars[i%4]*20+" "+str(cur_duration)+" "+chars[i%4]*20+" {} pkts captured".format(len(mqttc._userdata[PKTS].data)))
         sys.stdout.flush()
         time.sleep(0.25)
         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 wait_time_n_print(secs, txt=""):
+    if txt:
+        utPrint(txt, "CYAN")
+    utPrint(f"Waiting for {secs} seconds", "CYAN")
+    while secs:
+        print_update_wait()
+        secs -= 1
+
 def field_functionality_pass_fail_print(test, field, value=""):
     print_string = f"{field}={value}"
     if value == "":
@@ -105,11 +118,11 @@ def test_run_print(test):
     test_json_print(test)
     utPrint("Test Configuration:", "HEADER")
     params = [{'name':p.name, 'value':p.value} for p in test.params]
-    utPrint(f"""    - internal_brg={test.internal_brg}\n    - brg0={print_brg(test.brg0)}
-    - brg1={print_brg(test.brg1)}\n    - active_brg={print_brg(test.active_brg)}
+    utPrint(f"""    - internal_brg={test.internal_brg}\n    - tester={test.tester}
+    - dut={test.dut}\n    - brg1={test.brg1}\n    - active_brg={test.active_brg}
     - params={params}\n""")
-    cert_mqtt.write_to_mqtt_log_file(log_txt)
-    cert_data_sim.write_to_data_sim_log_file(log_txt)
+    write_to_log_file(DATA_SIM_LOG_FILE, log_txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, log_txt, "a")
 
 def test_json_print(test):
     for key, value in test.test_json.items():
@@ -131,14 +144,14 @@ def test_epilog_print(test):
 def functionality_run_print(func):
     txt = "{0}==>> Running {1}\n".format(SEP, func)
     utPrint(txt, "CYAN")
-    cert_mqtt.write_to_mqtt_log_file(txt)
-    cert_data_sim.write_to_data_sim_log_file(txt)
+    write_to_log_file(DATA_SIM_LOG_FILE, txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, txt, "a")
 
 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)
+    write_to_log_file(DATA_SIM_LOG_FILE, txt, "a")
+    write_to_log_file(CERT_MQTT_LOG_FILE, txt, "a")
 
 
 def generate_print_string(fields_and_values):
@@ -147,18 +160,6 @@ def generate_print_string(fields_and_values):
         list_to_print.append(str(f) + "=" + str(fields_and_values[f]))
     return " & ".join(list_to_print)
 
-def generate_log_file(test, val):
-    if type(val) == int or type(val) == str:
-        log_string = str(val)
-    else:
-        log_string = str(val[0])
-        for i in range(1,len(val)):
-            log_string += ","+ str(val[i])
-    if test.internal_brg:
-        log_string += "_internal_brg"
-
-    cert_mqtt.dump_pkts(test, log=log_string)
-
 ENERGY_GRAPH_HTML = """
 <h1 style="color:blue;text-align:center;">{}</h1>
 <div style="width:80%;margin:auto;"><canvas id="myChart"></canvas></div>

{brg_certificate → certificate}/cert_protobuf.py

@@ -1,7 +1,7 @@
 
-from brg_certificate.cert_defines import *
+from certificate.cert_defines import *
 
-import brg_certificate.wltPb_pb2 as wpb
+import common.wltPb_pb2 as wpb
 
 def action_pb(msg: dict):
     pb_msg = wpb.DownlinkMessage()
@@ -15,6 +15,13 @@ def tx_pkt_pb(msg: dict):
     pb_msg.txPacket.maxRetries = int(msg[TX_MAX_RETRIES])
     return pb_msg.SerializeToString()
 
+def gw_ota_pb(msg: dict):
+    pb_msg = wpb.DownlinkMessage()
+    pb_msg.gatewayUpgrade.imageDirUrl = msg[IMG_DIR_URL]
+    pb_msg.gatewayUpgrade.interfaceSwVersion = msg[WIFI_VERSION]
+    pb_msg.gatewayUpgrade.bleSwVersion = msg[BLE_VERSION]
+    return pb_msg.SerializeToString()
+
 def brg_ota_pb(msg: dict):
     pb_msg = wpb.DownlinkMessage()
     pb_msg.bridgeUpgrade.bridgeId = msg[BRIDGE_ID]
@@ -36,8 +43,8 @@ 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, and skip lat & lng to create duplicate values
-        if key == GW_MODE or key == LAT or key == LNG:
+        # Skip lat & lng to create duplicate values
+        if key == LAT or key == LNG:
             continue
         pb_value = wpb.GatewayConfigValue()
         if type(val) is int:
@@ -79,10 +86,12 @@ def custom_message_pb(msg: dict):
 
 def downlink_to_pb(msg: dict):
     if ACTION in msg.keys():
-        if msg[ACTION] == 0:
+        if msg[ACTION] == ACTION_ADVERTISING:
             return tx_pkt_pb(msg)
-        elif msg[ACTION] == 1:
+        elif msg[ACTION] == ACTION_BRG_OTA:
             return brg_ota_pb(msg)
+        elif msg[ACTION] == ACTION_GW_OTA:
+            return gw_ota_pb(msg)
         else:
             return action_pb(msg)
     elif GW_CONF in msg.keys():

{brg_certificate → certificate}/cert_results.py

@@ -1,7 +1,9 @@
 import os
+import shutil
 import tabulate
 import subprocess
 import datetime
+import zoneinfo
 from reportlab.lib import colors
 from reportlab.lib.pagesizes import letter
 from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, PageBreak, KeepTogether, Image
@@ -9,20 +11,18 @@ from reportlab.lib.styles import ParagraphStyle
 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.wlt_types import *
-from brg_certificate.cert_defines import *
+import certificate.cert_prints as cert_prints
+import certificate.cert_utils as cert_utils
+from certificate.wlt_types import *
+from 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!"
+WLT_CERT_HEADLINE =                "Wiliot Certificate {}"
+WLT_NON_CERT_HEADLINE =            "Wiliot Non-Certifying Run {}"
 SUMMARY_HEADLINE =                 "Summary"
 RUN_INFO =                         "Run Information"
 RUN_DATETIME =                     "Run Time & Date"
@@ -36,24 +36,31 @@ BLE_MAC_ADDRESS =                  "BLE MAC Address"
 BOARD_TYPE =                       "Board Type"
 BLE_VER =                          "BLE Version"
 SUP_API_VER =                      "Supported API Version"
+# TODO: This is a temporary list of all schema module names - remove this when auto generated
+MODULE_SCHEMA_NAMES_LIST = ["Cloud Connectivity", "Edge Management", "Calibration", "Datapath", "Energizer 2.4GHz",
+                            "Energizer Sub-1GHz", "Power Management", "BLE Sensor", "Custom"]
 
 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")}
+              TEST_PASSED: cert_prints.color("GREEN", "PASS"), TEST_ABORTED: cert_prints.color("RED", "ABORTED")}
 pass_or_fail = lambda obj : result_map[obj.rc]
+
+result_map_txt = {TEST_FAILED: "FAIL", TEST_SKIPPED: "SKIPPED", TEST_PASSED: "PASS", TEST_ABORTED: "ABORTED"}
+pass_or_fail_txt = lambda obj : result_map_txt[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
+headline_get = lambda non_cert_run, suffix : WLT_NON_CERT_HEADLINE.format(suffix) if non_cert_run else WLT_CERT_HEADLINE.format(suffix)
 
 class TestResult:
-    def __init__(self, name="", devices_to_print="", test_table=None, result=None, duration=0, purpose="", kb_link="", compliance="", test_skipped=False):
+    def __init__(self, name="", devices_to_print="", test_table=None, duration=0, purpose="", kb_link="", compliance="", rc=TEST_PASSED):
         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
-    
+        self.rc = rc
+
     def __repr__(self):
         return self.name
 
@@ -63,13 +70,14 @@ def generate_tests_table(tests=[], html=False):
     _pass_or_fail = pass_or_fail_html if html else pass_or_fail
     tests_results = []
     for test in tests:
-        brgs_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))
+        dut_to_print = (test.dut.internal_brg.id_str if isinstance(test.dut, cert_utils.Gateway) and test.dut.has_internal_brg()
+                        else test.dut.id_str)
+        dut_to_print += f"\n{test.brg1.id_str}" if test.brg1 and test.multi_brg else ""
         inner_table = [[phase.name, _pass_or_fail(phase), phase.reason] for phase in test.phases]
         result_breakdown_table = tabulate.tabulate(inner_table, headers=["Phase", "Result", "Notes"], tablefmt=inner_format)
         tests_results.append([cert_utils.module2name(test.test_module),
                               test.module_name if (not test.internal_brg or "gw" in test.module_name) else f"{test.module_name} (internal brg)",
-                              brgs_to_print,
+                              dut_to_print,
                               result_breakdown_table,
                               _pass_or_fail(test),
                               test.duration])
@@ -100,18 +108,51 @@ 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=datetime.datetime.now(), duration=0, brg=None, internal_brg=None, tests=[], error=None, pipeline=False):
+def get_important_tests_info():
+    patterns = ["DISCONNECTED", "WLT_ERROR", "free heap size", "python_mqtt_disconnect"]
+    return "".join([l.strip(' "') for l in open(os.path.join(ARTIFACTS_DIR, CERT_MQTT_LOG_FILE)).readlines() if any([p in l for p in patterns])])
+
+def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=0, skipped=0, start_time=datetime.datetime.now(), tests=[], error=None, non_cert_run=False):
+    print(cert_prints.SEP)
+    duration = (datetime.datetime.now()-start_time)
+    print("Tests duration: {}".format(str(duration).split(".")[0]))
+    pipeline = cert_prints.pipeline_running()
+    brg = None
+    if dut:
+        brg = dut.internal_brg if isinstance(dut, cert_utils.Gateway) and dut.has_internal_brg() else dut
+        if isinstance(brg, cert_utils.Bridge):
+            print("Bridge version: {}".format(brg.version))
+    if not error:
+        print(generate_tests_table(tests))
+        print(tabulate.tabulate([[len(tests), len(tests)-(failures+skipped), skipped, failures, len(tests)]],
+                                headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
+        print(cert_prints.WIL_CERT_TEXT)
+        cert_prints.print_warn(get_important_tests_info())
+    run_type = headline_get(non_cert_run, "").strip()
+    cert_prints.print_pass_or_fail(not failures and not error, run_type)
+
+    # Get internal_brg from dut or tester
+    internal_brg = None
+    if dut and isinstance(dut, cert_utils.Gateway) and dut.has_internal_brg():
+        internal_brg = dut.internal_brg
+    elif tester:
+        internal_brg = tester.internal_brg
+    
     # Generate HTML file
     if html:
-        f = open(os.path.join(BASE_DIR, UT_RESULT_FILE_HTML), "w", encoding="utf-8")
-        f.write(HTML_START)
+        file_path = os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_HTML)
+        f = open(file_path, "w", encoding="utf-8")
+        html_title = headline_get(non_cert_run, "Results")
+        html_start_modified = HTML_START.format(html_title)
+        f.write(html_start_modified)
         update_status = get_update_status_from_log_file()
         if pipeline:
             p = subprocess.Popen('git log --format=%B -n 1 {}'.format(os.environ['BITBUCKET_COMMIT']),
                                 stdout=subprocess.PIPE, shell=True, cwd=os.environ['BITBUCKET_CLONE_DIR'])
             output, err = p.communicate()
         if error:
-            f.write(f"<br><h1 style='color:#ab0000'>{WLT_CERT_ERROR_HEADLINE}</h1><br>")
+            headline = headline_get(non_cert_run, "Error!")
+            f.write(f"<br><h1 style='color:#ab0000'>{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']))
@@ -122,9 +163,11 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
                 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(f"<br><h1 style='color:#00AB83'>{WLT_CERT_PASS_HEADLINE}</h1>")
+                headline = headline_get(non_cert_run, "Passed!")
+                f.write(f"<br><h1 style='color:#00AB83'>{headline}</h1>")
             else:
-                f.write(f"<br><h1 style='color:#ab0000'>{WLT_CERT_FAIL_HEADLINE}</h1>")
+                headline = headline_get(non_cert_run, "Failed!")
+                f.write(f"<br><h1 style='color:#ab0000'>{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']))
@@ -135,7 +178,7 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
             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:
+            if isinstance(brg, cert_utils.Bridge):
                 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"))
@@ -146,11 +189,14 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
         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()
+        if pipeline:
+            # copy results for having it in the email
+            shutil.copy(file_path, os.path.join(os.getcwd(), UT_RESULT_FILE_HTML))
     
     # Generate PDF file
     if pdf:
-        doc = SimpleDocTemplate(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF), pagesize=letter)
-        doc.title = "Wiliot Certificate Results"
+        doc = SimpleDocTemplate(os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_PDF), pagesize=letter)
+        doc.title = headline_get(non_cert_run, "Results")
         elements, hdr_page = [], []
 
         # Add Wiliot Logo
@@ -160,6 +206,7 @@ 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_LINK_HEADER", ParagraphStyle("Default"))
@@ -168,13 +215,25 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
         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(f"<b>{WLT_CERT_ERROR_HEADLINE}</b>", red_header)
+            headline = headline_get(non_cert_run, "Error!")
+            title = Paragraph(f"<b>{headline}</b>", red_header)
             hdr_page.append(title)
             hdr_page.append(Spacer(1, 20))
             hdr_page.append(Paragraph(f"{error}", bold_text_style))
         else:
-            title = Paragraph(f"<b>{WLT_CERT_HEADLINE}</b>", black_header)
+            headline = headline_get(non_cert_run, "Results")
+            title = Paragraph(f"<b>{headline}</b>", black_header)
             hdr_page.append(title)
+        
+        # Add Passed/Failed status header
+        if not error:
+            is_passed = failures == 0
+            status_text = "Passed" if is_passed else "Failed"
+            status_header_style = green_header if is_passed else red_header
+            status_header = Paragraph(f"<b>{status_text}</b>", status_header_style)
+            hdr_page.append(Spacer(1, 10))
+            hdr_page.append(status_header)
+        
         hdr_page.append(Spacer(1, 20))
         hdr_page.append(Paragraph(f"<a name='{SUMMARY_HEADLINE}'/><b>{SUMMARY_HEADLINE}</b>", module_header))
         hdr_page.append(Spacer(1, 20))
@@ -186,10 +245,11 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
         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 isinstance(brg, cert_utils.Bridge):
+                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))
@@ -198,7 +258,27 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
             hdr_page.append(Paragraph(f"{SIM} {SUP_API_VER}: {internal_brg.api_version}", bold_text_style))
         hdr_page.append(Spacer(1, 20))
 
-        # Count Table
+        # Analyze results per module and generate results per module for PDF
+        results_per_module = generate_results_per_module_for_pdf(tests=tests)
+
+        # Modules Table
+        hdr_page.append(Paragraph(f"<b>Modules Overview</b>", module_header))
+        hdr_page.append(Spacer(1, 20))
+        modules_overview = get_modules_overview(results_per_module)
+        module_stats_table_data = []
+        for module_name, status in modules_overview.items():
+            module_stats_table_data.append([Paragraph(module_name, centered_text_style), pdf_result_map[status]])
+        module_stats_table = Table([["Module", "Status"]] + module_stats_table_data, colWidths=[100, 100])
+        module_stats_table.setStyle(inner_table_style('CENTER'))
+        hdr_page.append(module_stats_table)
+        hdr_page.append(Spacer(1, 20))
+        hdr_page.append(PageBreak())
+
+        # Tests Tables
+        hdr_page.append(Paragraph(f"<b>Tests Overview</b>", module_header))
+        hdr_page.append(Spacer(1, 20))
+
+        # Tests Count Table
         count_data = [
             ["PASSED", "SKIPPED", "FAILED", "TOTAL"],
             [len(tests)-(failures+skipped), skipped, failures, len(tests)]
@@ -207,26 +287,26 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
         count_table.setStyle(inner_table_style('CENTER'))
         hdr_page.append(count_table)
         hdr_page.append(Spacer(1, 20))
-
-        # Test Results
-        results_per_module = generate_results_per_module_for_pdf(tests=tests)
+        
+        # Tests Results Table
         summary_data = []
         for module, test_results in results_per_module.items():
             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(Paragraph(f"<b>{module + ' Module' if (not 'Edge' in module and not 'Cloud' in module) else module}</b>", module_header))
             module_objects.append(Spacer(1, 20))
             for test_result in test_results:
+                test_skipped = test_result.rc == TEST_SKIPPED
                 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]]
+                name = Paragraph(f'<a href="#{module}_{test_result.name}">{test_result.name}</a>', centered_text_style) if not test_skipped else test_result.name
+                summary_data += [[module, name, pass_or_fail_pdf(test_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(pass_or_fail_pdf(test_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:
+                if not 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))
@@ -245,6 +325,45 @@ def generate_results_files(html=True, pdf=True, failures=0, skipped=0, start_tim
 
         doc.build(elements)
 
+    # Upload pipeline results to DB
+    if pipeline:
+        import boto3
+        import json
+        import io
+        from botocore.exceptions import ClientError
+
+        device_id = brg.id_str if brg else internal_brg.id_str if internal_brg else "NO_ID"
+        version = brg.version if brg else internal_brg.version if internal_brg else "0.0.0"
+        json_data = {
+            "setup_name": os.environ['PIPELINE_NAME'],
+            "device_id": device_id,
+            "version": version,
+            "run_type": os.environ['PIPELINE_TYPE'],
+            "pipeline_url": f"https://bitbucket.org/wiliot/wiliot-nordic-firmware/pipelines/results/{os.environ['BITBUCKET_BUILD_NUMBER']}",
+            "run_datetime": str(datetime.datetime.now(zoneinfo.ZoneInfo("Asia/Jerusalem"))),
+            "passed_tests": len(tests)-(failures+skipped),
+            "failed_tests": failures,
+            "skipped_tests": skipped,
+            "total_tests": len(tests),
+            "run_time_seconds": duration.total_seconds(),
+            "tests": generate_results_for_db(tests)
+        }
+        print(json_data)
+
+        # upload to S3
+        timestamp = datetime.datetime.now().strftime("%d_%m_%Y_%H_%M_%S_%f")[:-3]
+        key = f"triggers/projects/fm-certificate/pending/{timestamp}/payload/data.json"
+        bucket = "wiliot-systemlab"
+        s3 = boto3.client("s3", region_name="us-east-1",
+                            aws_access_key_id=os.environ['DB_AWS_ACCESS_KEY'],
+                            aws_secret_access_key=os.environ['DB_AWS_SECRET_ACCESS_KEY'])
+
+        try:
+            body = io.BytesIO(json.dumps(json_data).encode())
+            s3.upload_fileobj(body, bucket, key)
+            print(f"Uploaded successfully to s3://{bucket}/{key}")
+        except ClientError as e:
+            print(f"S3 Error: {e}")
 
 ##################################
 # HTML
@@ -261,7 +380,7 @@ COLORS_HTML = {
 }
 color_html = lambda c, t: f'<span style="{COLORS_HTML.get(c, "")}{COLORS_HTML["BOLD"]}">{t}</span>'
 html_result_map = {TEST_FAILED: color_html("RED", "FAIL"), TEST_SKIPPED: color_html("WARNING", "SKIPPED"),
-                   TEST_PASSED: color_html("GREEN", "PASS"), TEST_INIT: color_html("CYAN", "INIT")}
+                   TEST_PASSED: color_html("GREEN", "PASS"), TEST_ABORTED: color_html("RED", "ABORTED")}
 pass_or_fail_html = lambda obj : html_result_map[obj.rc]
 
 HTML_START = """
@@ -270,7 +389,7 @@ HTML_START = """
     <head>
         <meta charset='utf-8'>
         <meta http-equiv='X-UA-Compatible' content='IE=edge'>
-        <title>Wiliot Certificate Results</title>
+        <title>{}</title>
         <meta name='viewport' content='width=device-width, initial-scale=1'>
         <style>
         html, body {{
@@ -325,6 +444,8 @@ HTML_END = """
 STYLES_PDF = {
     "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),
+    "GREEN_HEADER": ParagraphStyle("Green Header", fontName="Helvetica-Bold", fontSize=20, textColor=colors.green, alignment=TA_CENTER),
+    "GRAY": ParagraphStyle("Gray", fontName="Helvetica-Bold", fontSize=9, textColor=colors.grey, splitLongWords=False, alignment=TA_LEFT, wordWrap = 'CJK'),
     "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_LEFT),
     "TEST_LINK_HEADER": ParagraphStyle('Test Link Header', fontName="Helvetica-Bold", fontSize=14, textColor=colors.blue, alignment=TA_LEFT),
@@ -341,7 +462,8 @@ 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_SKIPPED: color_pdf("WARNING", "SKIPPED"), 
-                  TEST_PASSED: color_pdf("GREEN", "PASSED"),  TEST_INIT: color_pdf("CYAN", "INIT")}
+                  TEST_PASSED: color_pdf("GREEN", "PASSED"), TEST_ABORTED: color_pdf("RED", "ABORTED"),
+                  MODULE_UNSUPPORTED: color_pdf("GRAY", "UNSUPPORTED")}
 pass_or_fail_pdf = lambda obj : pdf_result_map[obj.rc]
 
 inner_table_style = lambda align :  TableStyle([
@@ -356,22 +478,57 @@ inner_table_style = lambda align :  TableStyle([
                                     ('WORDWRAP', (0, 0), (-1, -1), False),
                                 ])
 
+def get_modules_overview(results_per_module):
+    """Get modules overview for the tests."""
+    modules_overview = {}
+    for module_name in MODULE_SCHEMA_NAMES_LIST:
+        if module_name in results_per_module:  # Module is in run - check if it passed/failed/skipped
+            test_results = results_per_module[module_name]
+            modules_overview[module_name] = TEST_SKIPPED  # Assume all tests are skipped until proven otherwise
+            for test_result in test_results:
+                # If any test failed, the module failed
+                if test_result.rc == TEST_FAILED:
+                    modules_overview[module_name] = TEST_FAILED
+                    break
+                # If any test passed, the module passed until proven otherwise
+                elif test_result.rc == TEST_PASSED:
+                    modules_overview[module_name] = TEST_PASSED
+                # If any mandatory test is skipped, the module is skipped
+                elif test_result.rc == TEST_SKIPPED and test_result.compliance == "Mandatory":
+                    modules_overview[module_name] = TEST_SKIPPED
+        else:  # Module not in run - show as Unsupported
+            modules_overview[module_name] = MODULE_UNSUPPORTED
+    return modules_overview
+
+
 def generate_results_per_module_for_pdf(tests=[]):
     text_style = STYLES_PDF.get("BLACK", ParagraphStyle("Default"))
     results_per_module = {}
     for test in tests:
-        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))
+        devices_to_print = (f"{test.dut.id_str}\n{test.brg1.id_str}" if test.brg1 and test.multi_brg else test.dut.id_str)
         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('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))
+        test_result = TestResult(name=test.test_json[NAME], devices_to_print=devices_to_print, test_table=test_table, rc=test.rc,
+                                 duration=test.duration, purpose=str(test.test_json[PURPOSE]), compliance=compliance, kb_link=test.test_json[DOCUMENTATION])
         module_name = test.test_json[MODULE]
         if module_name not in results_per_module:
                 results_per_module[module_name] = [test_result]
         else:
             results_per_module[module_name] += [test_result]
     return results_per_module
+
+def generate_results_for_db(tests=[]):
+    results = []
+    for test in tests:
+        internal_brg_txt = " (internal brg)" if test.internal_brg else ""
+        result = {
+            "module_name": test.test_json[MODULE],
+            "test_name": test.test_json[NAME] + internal_brg_txt,
+            "result": pass_or_fail_txt(test),
+            "run_time": test.duration,
+        }
+        result["phases"] = [{"phase_name": param_name_to_title(phase.name), "result": pass_or_fail_txt(phase), "notes": phase.reason} for phase in test.phases]
+        results.append(result)
+    return results