wiliot-certificate 4.5.0a3__py3-none-any.whl → 4.5.0a4__py3-none-any.whl

certificate/cert_common.py

@@ -1,8 +1,6 @@
 from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
-from certificate.cert_utils import Phase
-from certificate.cert_utils import *
 import certificate.cert_utils as cert_utils
 import certificate.cert_config as cert_config
 import certificate.cert_mqtt as cert_mqtt
@@ -776,8 +774,7 @@ def scan_for_modules(test, modules=[]):
 
 
 def search_action_ack(test, action_id, **kwargs):
-    test, mgmt_pkts = cert_common.scan_for_mgmt_pkts(test,
-                                                     mgmt_type=[eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}')])
+    test, mgmt_pkts = scan_for_mgmt_pkts(test, mgmt_type=[eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}')])
     if test.rc == TEST_FAILED:
         return test
     print("\nReceived ACK pkts:")
@@ -1051,8 +1048,9 @@ def get_gw_type(mqttc):
 
 def get_module_if_pkt(test):
     cert_config.send_brg_action(test, ag.ACTION_GET_MODULE, interface=1)
-    test, pkts = scan_for_mgmt_pkts(test, mgmt_type=[eval_pkt(f'ModuleIfV{test.active_brg.api_version}'),
-                                                     eval_pkt(f'ModuleIfV{test.active_brg.api_version - 1}'),])
+    mgmt_type = [m for m in ag.MODULES_LIST if "ModuleIf" in m.__name__]
+    test, pkts = scan_for_mgmt_pkts(test, mgmt_type=mgmt_type)
+
     if test.rc == TEST_FAILED:
         return test, NO_RESPONSE
     else:
@@ -1273,10 +1271,28 @@ def output_power_supported(board_type, output_power):
     else:
         return output_power in ag.OUTPUT_POWER_2_4_SUPPORTED_VALUES
 
+
+def validate_received_packets(pkts_array):
+    for pkt in pkts_array:
+        # Check all required fields are present
+        if TIMESTAMP not in pkt:
+            return False, "timestamp field is missing in some of the packets"
+        if ALIAS_BRIDGE_ID not in pkt:
+            return False, "alias_bridge_id field is missing in some of the packets"
+        if PAYLOAD not in pkt:
+            return False, "payload field is missing in some of the packets"
+        if SEQUENCE_ID not in pkt:
+            return False, "sequence_id field is missing in some of the packets"
+        # Check that the payload length is either 62 or 74 hex characters (equevelnt to 31 or 37 bytes)
+        if len(pkt[PAYLOAD]) != 62 and len(pkt[PAYLOAD]) !=74:
+            return False, f"Payload length is invalid for packet {pkt[PAYLOAD]}"
+    return True, ""
+
+
 def wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts):
     PHASE_NAME = "Wiliot packets validation"
     phase_run_print(PHASE_NAME)
-    wiliot_pkts_validation_phase = Phase(PHASE_NAME, rc=TEST_PASSED)
+    wiliot_pkts_validation_phase = cert_utils.Phase(PHASE_NAME, rc=TEST_PASSED)
 
     if len(all_messages_in_test) == 0:
         wiliot_pkts_validation_phase.rc = TEST_FAILED
@@ -1358,9 +1374,9 @@ def timestamps_validation(wiliot_pkts_validation_phase, all_messages_in_test, up
                         return wiliot_pkts_validation_phase
                     previous_ts = inner_pkt[TIMESTAMP]
                 else:
-                    if inner_pkt[TIMESTAMP] < previous_ts:
+                    if inner_pkt[TIMESTAMP] <= previous_ts:
                         wiliot_pkts_validation_phase.rc = TEST_FAILED
-                        wiliot_pkts_validation_phase.reason = f'Timestamp is not incremental for inner packet {inner_pkt}'
+                        wiliot_pkts_validation_phase.reason = f'Timestamp is not incremental for inner packet {inner_pkt[PAYLOAD]}'
                         return wiliot_pkts_validation_phase
                     previous_ts = inner_pkt[TIMESTAMP]
     return wiliot_pkts_validation_phase
@@ -1438,21 +1454,22 @@ def stress_analysis(test, pps, sent_pkts, received_pkts):
     
     # PASS/FAIL logic
     if percentage_received < 1: # If less than 1% of the packets were received, fail the test
-        test.rc = TEST_FAILED
-        test.reason = "Insufficient amount of packets were scanned & uploaded by the gateway"
+        test.set_phase_rc(str(pps), TEST_FAILED)
+        test.add_phase_reason(str(pps), "Insufficient amount of packets were scanned & uploaded by the gateway")
     else:
-        test.reason = f'received pps: {received_pps} ({percentage_received}% of packets)'
+        test.set_phase_rc(str(pps), TEST_PASSED)
+        test.add_phase_reason(str(pps), f"received pps: {received_pps} ({percentage_received}% of packets)")
 
     return test, received_pps
 
 
 def generate_adv_payload(test_indicator, unique_pkt=False):
     # Keep last 4 bytes as zeroes so for incrementing them in FW 'ble_sim'
-    adva = hex2alias_id_get(cert_utils.get_random_hex_str(12))
-    unique_pkt_byte = cert_utils.get_random_hex_str(2) if unique_pkt == False else "00"
+    adva = hex2alias_id_get(get_random_hex_str(12))
+    unique_pkt_byte = get_random_hex_str(2) if unique_pkt == False else "00"
     payload = (ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() + test_indicator +
-               cert_utils.get_random_hex_str(32) + unique_pkt_byte + "00000000")
+               get_random_hex_str(32) + unique_pkt_byte + "00000000")
     return adva + payload
 
 def change_endianness(hex_str: str) -> str:
-    return ''.join(f"{b:02X}" for b in bytes.fromhex(hex_str)[::-1])
+    return ''.join(f"{b:02X}" for b in bytes.fromhex(hex_str)[::-1])

certificate/cert_config.py

@@ -41,6 +41,8 @@ def gw_configure(test, cfg={}, version="", extended_cfg={}, ret_pkt=False, wait=
             for p in cert_mqtt.get_all_status_pkts(mqttc):
                 if GW_CONF in p or GW_STATUS in p:
                     test.gw_api_version = p[GW_CONF][GW_API_VERSION] if GW_CONF in p else p[GW_STATUS][GW_API_VERSION]
+                    if target == DUT and is_gw(test.dut):
+                        test.dut.gw_api_version = test.gw_api_version
                     print_pkt(p)
                     utPrint("SUCCESS: Found GW cfg", "GREEN")
                     wait_time_n_print(2)
@@ -351,9 +353,7 @@ def get_default_brg_pkt(test, pkt_type, group_id=ag.GROUP_ID_GW2BRG, seq_id=0, t
     seq_id = test.get_seq_id() if seq_id == 0 else seq_id
     # Bypass from default sub1g ep cfg of 0 (no energizing) ONLY if not using data simulation
     if "ModuleEnergySub1G" in pkt_type.__name__ and BRG_PATTERN not in kwargs and test.data != DATA_SIMULATION:
-        # TODO - Remove on next api_version update - this is a patch for parameter name change from api version 11 to 12
-        brg_pattern = "sub1g_energy_" + BRG_PATTERN if brg.api_version < ag.API_VERSION_V12 else BRG_PATTERN
-        kwargs.update({brg_pattern: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
+        kwargs.update({BRG_PATTERN: ag.SUB1G_ENERGY_PATTERN_ISRAEL})
     brg_pkt = WltPkt(hdr=ag.Hdr(group_id=group_id), pkt=pkt_type(brg_mac=brg.id_int if brg else 0, seq_id=seq_id, **kwargs))
     return brg_pkt
 

certificate/cert_data_sim.py

@@ -23,10 +23,10 @@ SECONDARY_CHANNEL_10       = 10
 SECONDARY_CHANNEL_21       = 21
 
 # Randomize pixel simulation indicator once per run (6 hex chars)
-PIXEL_SIM_INDICATOR        = cert_utils.get_random_hex_str(6)
+PIXEL_SIM_INDICATOR = get_random_hex_str(6)
 
 def init_adva(flow_version_major=0x4, flow_version_minor=0x34):
-    return "{0:02X}".format(flow_version_major) + cert_utils.get_random_hex_str(8) + "{0:02X}".format(flow_version_minor)
+    return "{0:02X}".format(flow_version_major) + get_random_hex_str(8) + "{0:02X}".format(flow_version_minor)
 
 random_bytes = lambda n: int.from_bytes(os.urandom(n), "big")
 
@@ -41,15 +41,16 @@ def brg_pkt_gen(num_of_pkts_per_brg, num_of_brgs, brgs_list=[], pkt_type=PIXELS_
         if brgs_list:
             brg_mac = brgs_list[i]
         else:
-            brg_mac = cert_common.hex2alias_id_get(cert_utils.get_random_hex_str(12))
+            brg_mac = cert_common.hex2alias_id_get(get_random_hex_str(12))
             bridge_ids.append(brg_mac)
         adva = cert_common.change_endianness(brg_mac) # Change endianness to little endian
-        
+
         for j in range(num_of_pkts_per_brg):
-            serial_pkt_id = f"{i % 256:02X}{j % 256:02X}{idx:04X}"
-            
+            serial_pkt_id = f"{i % 256:02X}{j % 256:02X}{idx:04X}"  # 8 hex chars - 4 bytes
+
             if pkt_type == PIXELS_PKT:
-                payload = ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
+                payload = (ag.Hdr(group_id=ag.GROUP_ID_UNIFIED_PKT_V2).dump() +
+                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
 
             if pkt_type == MGMT_PKT:
                 mgmt_pkt = eval_pkt(f'GenericV{ag.API_VERSION_LATEST}')
@@ -57,10 +58,12 @@ def brg_pkt_gen(num_of_pkts_per_brg, num_of_brgs, brgs_list=[], pkt_type=PIXELS_
                 payload = ag.Hdr(group_id=ag.GROUP_ID_BRG2GW).dump() + body.dump()[:-14] + indicator + serial_pkt_id
 
             if pkt_type == SENSOR_PKT:
-                payload = ag.Hdr(uuid_msb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB, uuid_lsb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
+                payload = (ag.Hdr(uuid_msb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_MSB, uuid_lsb=ag.HDR_DEFAULT_BRG_SENSOR_UUID_LSB).dump() +
+                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
 
             if pkt_type == SIDE_INFO_SENSOR_PKT:
-                payload = ag.Hdr(group_id=ag.GROUP_ID_SIDE_INFO_SENSOR).dump() + indicator + cert_utils.get_random_hex_str(34) + serial_pkt_id
+                payload = (ag.Hdr(group_id=ag.GROUP_ID_SIDE_INFO_SENSOR).dump() +
+                           indicator + brg_mac + get_random_hex_str(22) + serial_pkt_id)
 
             idx += 1
             pkts += [GenericPkt(adva=adva, payload=payload)]

certificate/cert_defines.py

@@ -1,11 +1,16 @@
 # Files
 import os
+import random
 import datetime
 import importlib.metadata
 import certificate.ag.wlt_types_ag as ag
+
+get_random_hex_str = lambda n: ''.join([random.choice('0123456789ABCDEF') for _ in range(n)])
+
 # BASE_DIR should be initiated in the same dir as certificate.py
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 ARTIFACTS_DIR = os.path.join(os.getcwd(), f"cert_artifacts_{datetime.datetime.now().strftime("%d_%m_%Y__%H_%M_%S")}")
+
 # CERT_VERSION handling - local/PyPi
 LOCAL_DEV = "local-dev"
 try:
@@ -278,6 +283,7 @@ GW_LONGITUDE_DEFAULT =                      -117.0839
 GW_API_VER_DEFAULT =                "201"
 GW_API_VER_OLD =                    "200"
 GW_API_VER_LATEST =                 "206"
+API_OLDEST_SUPPORTED_VERSION =      ag.API_VERSION_V12
 BRG_CFG_HAS_LEN =                   2
 CLEAR_DATA_PATH_TIMEOUT =           10
 ACTION_LONG_TIMEOUT =               120

certificate/cert_gw_sim.py

@@ -330,10 +330,10 @@ def handle_cmds(input, ble_serial):
         GW_SIM_RESET_TS = datetime.datetime.now()
         write_to_ble(ble_serial, RESET_GW, sleep=0)
     if input.startswith(RX_NORDIC_RECOVER_NORESET):
-        utPrint(f"Simulator recovered", "CYAN")
+        utPrint(f"COM tester recovered", "CYAN")
         write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 
-def gw_sim_run(port, gw_id, custom_broker, analyze_interference=False):
+def gw_sim_run(port, gw_id, custom_broker, disable_interference_analyzer=False):
 
     # Init serial side
     if not port:
@@ -378,7 +378,7 @@ def gw_sim_run(port, gw_id, custom_broker, analyze_interference=False):
     write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 
     # Run interference analysis
-    if analyze_interference:
+    if not disable_interference_analyzer:
         print(color("BLUE", f"\nStarting interference analysis for channels {[ch[0] for ch in CHANNELS_TO_ANALYZE]}. This will take {30 * len(CHANNELS_TO_ANALYZE)} seconds (total)"))
         interference_analysis(ble_serial)
 

certificate/cert_mqtt.py

@@ -198,7 +198,8 @@ def on_message_json(mqttc, userdata, message):
     wlt_mqtt_pkts = userdata[PKTS]
     data = json.loads(message.payload.decode("utf-8"))
     wlt_mqtt_pkts.insert(WltMqttPkt(data, message.topic, userdata))
-    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
+    text = json.dumps(json.loads(message.payload.decode("utf-8")), indent=4)
+    write_to_mqtt_log_file("// JSON message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, text))
 
 def on_message_protobuf(mqttc, userdata, message):
     pb_msg = None
@@ -264,9 +265,9 @@ def load_custom_broker(broker_filepath, gw):
     except FileNotFoundError:
         raise FileNotFoundError(f"No such file: {broker_filepath}")
     data = json.load(f)
-    data[CUSTOM_BROKER_UPDATE_TOPIC] += gw
-    data[CUSTOM_BROKER_STATUS_TOPIC] += gw
-    data[CUSTOM_BROKER_DATA_TOPIC] += gw
+    data[CUSTOM_BROKER_UPDATE_TOPIC] = data[CUSTOM_BROKER_UPDATE_TOPIC].replace(f'<{GW_ID}>', gw)
+    data[CUSTOM_BROKER_STATUS_TOPIC] = data[CUSTOM_BROKER_STATUS_TOPIC].replace(f'<{GW_ID}>', gw)
+    data[CUSTOM_BROKER_DATA_TOPIC] = data[CUSTOM_BROKER_DATA_TOPIC].replace(f'<{GW_ID}>', gw)
     return data
 
 def mqttc_init(gw_id, custom_broker, data=DATA_REAL_TAGS):

certificate/cert_results.py

@@ -31,6 +31,7 @@ CERT_VER =                         "Certificate Version"
 TESTING_DEVICE_INFO =              "Testing Device Information"
 TESTED_DEVICE_INFO =               "Tested Device Information"
 SIM =                              "Simulator"
+GATEWAY =                          "Gateway"
 BRG =                              "Bridge"
 BLE_MAC_ADDRESS =                  "BLE MAC Address"
 BOARD_TYPE =                       "Board Type"
@@ -113,32 +114,24 @@ 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):
+def generate_results_files(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))
+    test = tests[-1] if tests else None
+    if test and test.dut_is_bridge():
+        print("Bridge version: {}".format(test.dut.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())
+    print(f"Run artifacts saved in \"{ARTIFACTS_DIR}\" directory")
     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:
         file_path = os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_HTML)
@@ -160,8 +153,8 @@ def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=
             f.write(update_status + "<br><br>")
             f.write(error + "<br><br>")
             f.write(f"{RUN_DUR}: {str(duration).split('.')[0]} <br><br>")
-            if brg:
-                f.write(f"{BRG} {BLE_VER}: {brg.version} <br><br>")
+            if test and test.dut_is_bridge():
+                f.write(f"{BRG} {BLE_VER}: {test.dut.version} <br><br>")
         elif tests:
             if not failures and ("successfully!" in update_status or "skipped!" in update_status or not pipeline):
                 headline = headline_get(non_cert_run, "Passed!")
@@ -176,12 +169,19 @@ def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=
             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 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>")
+            if test and test.dut_is_gateway():
+                f.write(f"{GATEWAY} ID: {test.dut.id_str} <br><br>")
+                f.write(f"{GATEWAY} {SUP_API_VER}: {test.dut.gw_api_version} <br><br>")
+                if test.dut_is_combo():
+                    f.write(f"{BRG} {BLE_MAC_ADDRESS}: {test.dut.internal_brg.id_str} <br><br>")
+                    f.write(f"{BRG} {BLE_VER}: {test.dut.internal_brg.version} <br><br>")
+            if test.dut_is_bridge():
+                f.write(f"{BRG} {BLE_MAC_ADDRESS}: {test.dut.id_str} <br><br>")
+                f.write(f"{BRG} {BLE_VER}: {test.dut.version} <br><br>")
+            if test.tester:
+                f.write(f"{SIM} {BLE_MAC_ADDRESS}: {test.tester.internal_brg.id_str} <br><br>")
+                f.write(f"{SIM} {BLE_VER}: {test.tester.internal_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>")
@@ -243,20 +243,26 @@ def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=
         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:
+        if test:
             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))
-            if isinstance(brg, cert_utils.Bridge):
+            if test.dut_is_gateway():
+                hdr_page.append(Paragraph(f"{GATEWAY} ID: {test.dut.id_str}", bold_text_style))
+                hdr_page.append(Paragraph(f"{GATEWAY} {SUP_API_VER}: {test.dut.gw_api_version}", bold_text_style))
+            if test.dut_is_combo() or test.dut_is_bridge():
+                brg = test.dut.internal_brg if test.dut_is_combo() else test.dut
+                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))
+
+            # In wlt-cert-reg there is no tester
+            if test.tester:
+                hdr_page.append(Paragraph(f"<u>{TESTING_DEVICE_INFO}:</u>", bold_text_style))
+                hdr_page.append(Paragraph(f"{SIM} {BLE_MAC_ADDRESS}: {test.tester.internal_brg.id_str}", bold_text_style))
+                hdr_page.append(Paragraph(f"{SIM} {BOARD_TYPE}: {ag.BOARD_TYPES_LIST[test.tester.internal_brg.board_type]}", bold_text_style))
+                hdr_page.append(Paragraph(f"{SIM} {BLE_VER}: {test.tester.internal_brg.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))
         notes_file_path = os.path.join(ARTIFACTS_DIR, RESULT_NOTES_FILE)
         if os.path.exists(notes_file_path):
             hdr_page.append(Paragraph(f"<u>{ADD_INFO}:</u>", bold_text_style))
@@ -340,8 +346,12 @@ def generate_results_files(dut=None, tester=None, html=True, pdf=True, failures=
         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"
+        if test:
+            device_id = f"{test.dut.id_str}:{test.dut.internal_brg.id_str}" if test.dut_is_combo() else test.dut.id_str
+            version = test.dut.internal_brg.version if test.dut_is_combo() else test.dut.version
+        else:
+            device_id = "NO_ID"
+            version = "0.0.0"
         json_data = {
             "setup_name": os.environ['PIPELINE_NAME'],
             "device_id": device_id,

certificate/cert_utils.py

@@ -26,10 +26,6 @@ ORIGINAL_AG_FILE =  "wlt_types_ag.py"
 TEST_MODULES_MAP = {"calibration": ag.MODULE_CALIBRATION, "datapath": ag.MODULE_DATAPATH, "energy2400": ag.MODULE_ENERGY_2400, "energy_sub1g": ag.MODULE_ENERGY_SUB1G,
                     "pwr_mgmt": ag.MODULE_PWR_MGMT, "sensors": ag.MODULE_EXT_SENSORS, "custom": ag.MODULE_CUSTOM}
 
-# Used when mac is not really important for the test (e.g: gw_sim) or to randomize pkt data
-def get_random_hex_str(len=12):
-    return ''.join([random.choice('0123456789ABCDEF') for i in range(len)])
-
 def module2name(module_id):
     for k, v in TEST_MODULES_MAP.items():
         if module_id == v:
@@ -308,6 +304,8 @@ class Bridge:
         self.cfg_hash = interface_pkt.cfg_hash if interface_pkt else cfg_hash
         self.api_version = interface_pkt.api_version if interface_pkt else api_version
         if import_defs:
+            if self.board_type >= len(ag.BOARD_TYPES_LIST):
+                handle_error(f"ERROR: Unknown board type {self.board_type} for bridge {self.id_str}!", datetime.datetime.now())
             self.defines_file_name = f'{ag.BOARD_TYPES_LIST[self.board_type]}_defines.cfg'
             overwrite_dict = {}
             # Overwrite auto-generated defines for the specific bridge
@@ -388,7 +386,7 @@ def ut_prep_brg(args, start_time, tester, brg_id, tester_flag=False, validation_
     if args.latest or args.rc:
         return handle_prep_brg_for_latest(test, interface, brg_id, start_time)
     elif test.rc == TEST_FAILED:
-        error = f"ERROR: Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!"
+        error = f"ERROR: Didn't get ModuleIfV{test.active_brg.api_version} from BRG:{brg.id_str}!\n Check that the brg responded with the correct module"
         handle_error(error, start_time)
     version = f"{interface.major_ver}.{interface.minor_ver}.{interface.patch_ver}"
     board_type = interface.board_type
@@ -465,7 +463,7 @@ class Gateway:
 
 def get_tester_id(tester):
     if not tester or tester == GW_SIM_PREFIX:
-        return f"GW_SIM_{get_random_hex_str()}"
+        return f"GW_SIM_{get_random_hex_str(12)}"
     else:
         # Allow tester to be specified as tester_id:ble_addr
         if ':' in tester:
@@ -515,16 +513,16 @@ def prep_dut(args, tester, validation_schema, mqttc, start_time, upload_wait_tim
         # Prepare gateway's internal BRG
         if brg_flag(validation_schema):
             dut.internal_brg = ut_prep_brg(args, start_time, tester=test.dut, brg_id=args.combo_ble_addr, validation_schema=validation_schema['modules'])
-            if dut.internal_brg.api_version != ag.API_VERSION_LATEST:
-                handle_error(f"ERROR: Certificate FW api_version={dut.internal_brg.api_version} instead of api_version={ag.API_VERSION_LATEST}! Please upgrade the FW!", start_time)
+            if dut.internal_brg.api_version < API_OLDEST_SUPPORTED_VERSION:
+                 handle_error(f"ERROR: DUT internal brg FW api_version={dut.internal_brg.api_version} is lower then the oldest supported = {API_OLDEST_SUPPORTED_VERSION}! Please upgrade the internal brg FW!", start_time)
         # Return Gateway object
         return dut
 
     elif brg_flag(validation_schema):
         # Prepare standalone bridge using prepared tester
         brg = ut_prep_brg(args, start_time, tester=tester, brg_id=args.dut, validation_schema=validation_schema['modules'])
-        if brg.api_version != ag.API_VERSION_LATEST:
-            handle_error(f"ERROR: DUT FW api_version={brg.api_version} instead of api_version={ag.API_VERSION_LATEST}!", start_time)
+        if brg.api_version < API_OLDEST_SUPPORTED_VERSION:
+            handle_error(f"ERROR: DUT brg FW api_version={brg.api_version} is lower then the oldest supported = {API_OLDEST_SUPPORTED_VERSION}! Please upgrade the brg FW!", start_time)
         return brg
 
 
@@ -613,6 +611,7 @@ def prep_gw_info_action(test, start_time, brg_flag, target):
             gw.gw_version = {BLE_VERSION : info[BLE_VERSION], WIFI_VERSION : info[WIFI_VERSION]}
         if brg_flag and BLE_MAC_ADDR in info:
             internal_brg_mac_addr = info[BLE_MAC_ADDR]
+        # For internal use only in versions update test 
         if GW_API_VERSION in info:
             gw.gw_api_version = info[GW_API_VERSION]
 

certificate/certificate.py

@@ -101,11 +101,12 @@ def main(args):
 
     utPrint(f"wiliot_certificate version: {CERT_VERSION}")
     utPrint(str(args.__dict__))
-    os.makedirs(ARTIFACTS_DIR, exist_ok=True)
     start_time = datetime.datetime.now()
 
     # Clean
     clean(args)
+    # Create artifacts dir
+    os.makedirs(ARTIFACTS_DIR, exist_ok=True)
 
     # Filter tests
     test_list = TEST_LIST_FW_UPDATE_FILE if args.latest or args.rc else args.tl
@@ -130,9 +131,9 @@ def main(args):
         # Run Gateway Simulator in separate thread
         gw_sim_thread = threading.Thread(target=cert_gw_sim.gw_sim_run, daemon=True, kwargs={'port':args.port, 'gw_id': args.tester,
                                                                                              'custom_broker':args.custom_broker,
-                                                                                             'analyze_interference':args.analyze_interference})
+                                                                                             'disable_interference_analyzer':args.disable_interference_analyzer})
         gw_sim_thread.start()
-        sleep_time = (len(cert_gw_sim.CHANNELS_TO_ANALYZE) * 30) + 15 if args.analyze_interference else 10
+        sleep_time = (len(cert_gw_sim.CHANNELS_TO_ANALYZE) * 30) + 15 if not args.disable_interference_analyzer else 10
         time.sleep(sleep_time)
     tester = cert_utils.prep_tester(args, tester_mqttc, start_time, gw_sim_thread)
     
@@ -182,12 +183,13 @@ def main(args):
         print(f"Test Duration: {test.duration}")
         print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
                             headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
-        wait_time_n_print(2)
+        if test.rc != TEST_SKIPPED:
+            wait_time_n_print(2)
         if exit_on_test_failure and test.rc == TEST_FAILED:
             break
 
     # Print results
-    cert_results.generate_results_files(test.dut, test.tester, html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, tests=tests, non_cert_run=args.non_cert_run)
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, tests=tests, non_cert_run=args.non_cert_run)
     if not pipeline_running():
         webbrowser.open('file://' + os.path.realpath(os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_PDF)))
 

certificate/certificate_cli.py

@@ -24,18 +24,16 @@ class CertificateCLI:
             description='Certificate - CLI Tool to test Wiliot Devices',
             epilog=
             "run examples:\n"
-            "  Run command example with COM PORT connection:\n"
-            "  wlt-cert-cli --gw SIM --brg <XXXXXXXXXXXX> --port <COM_PORT>\n"
-            "  Run command example with remote GW connection:\n"
-            "  wlt-cert-cli --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX>\n"
+            "  Run command example with COM PORT tester:\n"
+            "  wlt-cert-cli --tester SIM --dut <XXXXXXXXXXXX> --port <COM_PORT>\n"
+            "  Run command example with remote GW tester:\n"
+            "  wlt-cert-cli --tester <YYYYYYYYYYYY> --dut <XXXXXXXXXXXX>\n"
             "  Run command example for running datapath module tests only:\n"
-            "  wlt-cert-cli --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --run datapath\n"
+            "  wlt-cert-cli --tester <YYYYYYYYYYYY> --dut <XXXXXXXXXXXX> --run datapath\n"
             "  Run command example with sanity test list:\n"
-            "  wlt-cert-cli --gw <YYYYYYYYYYYY> --brg <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt\n"
-            "  Run command example with COM PORT connection for bridge with cloud connectivity:\n"
-            "  wlt-cert-cli --gw SIM --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt --port <COM_PORT>\n"
-            "  Run command example with remote GW connection for bridge with cloud connectivity:\n"
-            "  wlt-cert-cli --gw <YYYYYYYYYYYY> --brg_cloud_connectivity <XXXXXXXXXXXX> --tl certificate_bcc_test_list.txt\n",
+            "  wlt-cert-cli --tester <YYYYYYYYYYYY> --dut <XXXXXXXXXXXX> --tl certificate_sanity_test_list.txt\n"
+            "  Run command example with COM PORT tester for combo device:\n"
+            "  wlt-cert-cli --tester SIM --dut <XXXXXXXXXXXX>:<YYYYYYYYYYYY> --port <COM_PORT>\n",
             formatter_class=argparse.RawDescriptionHelpFormatter
         )
         self.parser.add_argument('--validation_schema', '-vs', required=True, help='Validation schema json file path to use for the run')
@@ -52,8 +50,7 @@ class CertificateCLI:
         self.parser.add_argument('--exit_on_test_failure', default=False, action='store_true', help='Stop running the tests if a test failed ' + argparse.SUPPRESS)
         self.parser.add_argument('--exit_on_param_failure', default=False, action='store_true', help='Sets exit_on_param_failure mode to true in order to prevent \
                                  tests from continuing iteration over all possibilities in case of failure ' + argparse.SUPPRESS)
-        self.parser.add_argument('--analyze_interference', '-ai', default=False, action='store_true', help='Analyze interference before tests start \
-                                 (relevant only for Gateway Simulator)')
+        self.parser.add_argument('--disable_interference_analyzer', '-dia', default=False, action='store_true', help='Disable interference analysis before tests')
         self.parser.add_argument('--unsterile_run', '-ur', default=False, action='store_true',
                                  help="Set unsterile run mode for the run if there are pixels or energizing devices nearby")
         self.parser.add_argument("--overwrite_defaults", '-od', type=parse_dict_arg, help='Manually overwrite default defines for the bridge (key1=value1,key2=value2...)')

certificate/tests/cloud_connectivity/acl_test/acl_test.py

@@ -8,7 +8,7 @@ import certificate.cert_data_sim as cert_data_sim
 from certificate.ag.wlt_types_ag import *
 
 SCAN_TIMEOUT = 30
-
+NUM_OF_BRGS = 4
 # DEFINES
 test_indicator = cert_data_sim.PIXEL_SIM_INDICATOR
 
@@ -20,11 +20,11 @@ def run(test):
         return cert_common.test_epilog(test)
 
     # Generate management and data packets
-    bridge_ids = []
-    pixels_pkts, bridge_ids = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=20, num_of_brgs=4,
-                                                        pkt_type=PIXELS_PKT, indicator=test_indicator)
+    bridge_ids = [cert_common.hex2alias_id_get(get_random_hex_str(12)) for _ in range(NUM_OF_BRGS)]
+    pixels_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=20, num_of_brgs=NUM_OF_BRGS, brgs_list=bridge_ids,
+                                               pkt_type=PIXELS_PKT, indicator=test_indicator)
 
-    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=4, brgs_list=bridge_ids,
+    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=10, num_of_brgs=NUM_OF_BRGS, brgs_list=bridge_ids,
                                              pkt_type=MGMT_PKT, indicator=test_indicator)
     # Use first 3 bridges for ACL, 4th bridge is not in ACL
     acl_bridge_ids = bridge_ids[:3]
@@ -41,7 +41,7 @@ def run(test):
         cfg = cert_config.get_default_gw_dict(test)
         cfg[ACL][ACL_BRIDGE_IDS] = acl_bridge_ids
         cfg[ACL][ACL_MODE] = param.value
-        test, ret = cert_config.gw_configure(test, cfg=cfg, wait=True)
+        test, _ = cert_config.gw_configure(test, cfg=cfg, wait=True)
         print_update_wait(1)
 
         test.get_mqttc_by_target(DUT).flush_pkts()
@@ -51,8 +51,8 @@ def run(test):
         # Analyze pass/fail
         # Get all received packets with the test indicator and filter packets by bridge IDs in ACL list
         received_pkts = cert_mqtt.get_unified_data_pkts(test, only_active_brg=False, indicator=test_indicator)
-        acl_bridge_pkts = [pkt for pkt in received_pkts if pkt[ALIAS_BRIDGE_ID] in acl_bridge_ids]
-        non_acl_bridge_pkts = [pkt for pkt in received_pkts if pkt[ALIAS_BRIDGE_ID] in non_acl_bridge_id]
+        acl_bridge_pkts = [pkt for pkt in received_pkts if any([id in pkt[PAYLOAD] for id in acl_bridge_ids])]
+        non_acl_bridge_pkts = [pkt for pkt in received_pkts if non_acl_bridge_id in pkt[PAYLOAD]]
 
         # In deny mode - we want to make sure bridges in ACL list are filtered
         if param.value == ACL_DENY:
@@ -71,20 +71,18 @@ def run(test):
                 test.add_reason(f"Phase failed! Bridge {non_acl_bridge_id} was not on the allow list "
                                 f"and {len(non_acl_bridge_pkts)} packets were found from it")
             # Check that we received packets from all expected bridges
-            received_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in acl_bridge_pkts])
-            if received_bridge_ids != set(acl_bridge_ids):
+            received_alias_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in acl_bridge_pkts])
+            if len(received_alias_bridge_ids) != len(acl_bridge_ids):
                 test.rc = TEST_FAILED
                 test.add_reason("Phase failed! Didn't receive packets from all bridges that were on the allow list")
 
         # Check that management packets are received from all bridges (ACL doesn't filter mgmt packets)
         all_mgmt_pkts = cert_mqtt.get_all_mgmt_pkts(test.get_mqttc_by_target(DUT), indicator=test_indicator)
-        mgmt_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in all_mgmt_pkts])
+        mgmt_alias_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in all_mgmt_pkts])
 
-        if not set(bridge_ids).issubset(mgmt_bridge_ids):
+        if len(mgmt_alias_bridge_ids) != NUM_OF_BRGS:
             test.rc = TEST_FAILED
-            missing_bridges = set(bridge_ids) - mgmt_bridge_ids
-            test.add_reason(f"Phase failed! Expected management packets from all bridges, "
-                            f"whether they are on the ACL or not, but missing from BRG {missing_bridges}")
+            test.add_reason("Phase failed! Didn't receive management packets from all bridges")
 
         field_functionality_pass_fail_print(test, "ACL", value=param.value)
         test.set_phase_rc(param.name, test.rc)

certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.json

@@ -9,7 +9,7 @@
                   "Analyze if bridge was upgraded and action status message was uploaded",
                   "Test epilog"],
     "expectedOutcome": "Tester brg advertises ModuleIF packet with the new version and DUT Gateway publish an actionStatus message indicating success and  within timeout",
-    "mandatory": 1,
+    "mandatory": 0,
     "multiBridgeTest": 0,
     "gwOnlyTest": 1,
     "internalBridge": 1,

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py

@@ -3,7 +3,6 @@ from certificate.cert_defines import *
 from certificate.wlt_types import *
 from certificate.ag.wlt_types_ag import OUTPUT_POWER_2_4_MAX
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_config as cert_config
 import certificate.cert_gw_sim as cert_gw_sim
@@ -18,7 +17,7 @@ from collections import defaultdict
 # DEFINES
 CHANNELS = [37, 38, 39]  # channel to check in DUT
 DEFAULT_WAIT_TIME = 5  # How much extra time to wait after the transmition is over
-SCAN_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)  # Unique identifier for the pkt sent
+SCAN_TEST_INDICATOR = get_random_hex_str(6)  # Unique identifier for the pkt sent
 ADV_DURATION = 20  # How long to transmit to the DUT
 # cmd_ble_sm defines
 BLE_SIM_RADIO_1MBPS = 1
@@ -84,6 +83,7 @@ def analyze_listening_timeline(test, all_pkts_received_from_tester, num_of_sent_
     channel_cards = []
 
     # Parse data into {ts, channel pairs} - X and Y axis
+    all_pkts_received_from_tester = sorted(all_pkts_received_from_tester, key=lambda pkt: float(pkt.get(TIMESTAMP)))
     for idx, pkt in enumerate(all_pkts_received_from_tester):
         payload = pkt.get(PAYLOAD)
         channel = int(payload[-10:-8], 16)