wiliot-certificate 4.5.0a2__tar.gz → 4.5.0a4__tar.gz

{wiliot_certificate-4.5.0a2/src/wiliot_certificate.egg-info → wiliot_certificate-4.5.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 4.5.0a2
+Version: 4.5.0a4
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: reportlab>=4.3.1
 Requires-Dist: google-api-python-client>=2.162.0
 Dynamic: license-file
 
-# wiliot-certificate Version 4.5.0
+# wiliot-certificate
 
 <!-- Description -->
 wiliot-certificate is a Python library that provides tools for testing and certifying boards for compatibility with Wiliot’s ecosystem.
@@ -40,30 +40,27 @@ This python package includes the following tools:
  - Tester Upgrade (`wlt-cert-tester-upgrade`)
  - Registration Certificate (`wlt-cert-reg`)
 
-# Version: 
-wiliot-certificate versions 4.5.0 are compatible with firmware version >=4.5.0 (API VERSION: 13)
+# Versioning: 
+wiliot-certificate versions 4.5.x are compatible with firmware version >=4.5.0 (API VERSION: 13)
 
 ## Installing wiliot-certificate
-Install wiliot-certificate:
 ````commandline
 pip install wiliot-certificate
 ````
 
 ## Using wiliot-certificate
 ### Certification
-In terminal, run:
 ````commandline
 wlt-cert
 ````
 This tool is the default to test and certify your device.
 It runs a setup wizard that walks you through the initialization steps before running the tests.
-You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file ([more info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)).
+You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file (more info [here](https://community.wiliot.com/customers/s/article/Wiliot-Certification)).
 Once set up it opens a terminal and tests your device.
 
 
 
 ### Certificate CLI
-In terminal, run:
 ````commandline
 wlt-cert-cli -h
 ````
@@ -71,7 +68,6 @@ CLI version of the certificate. Use -h for details on the different arguments.
 
 
 ### Tester Upgrade
-In terminal, run:
 ````commandline
 wlt-cert-tester-upgrade
 ````
@@ -79,13 +75,12 @@ Upgrades the firmware of the tester device to the version required for certifica
 
 
 ### Registration Certificate
-In terminal, run:
 ````commandline
 wlt-cert-reg
 ````
 Certify the gateway registration process to Wiliot platform.
 The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
-Use -h for details on the arguments. [More info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)
+Use -h for details on the arguments (see [Registration](https://community.wiliot.com/customers/s/article/Wiliot-Certification) for more info).
 
 
 ## The following capabilities are not tested in this version

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/README.md

@@ -1,4 +1,4 @@
-# wiliot-certificate Version 4.5.0
+# wiliot-certificate
 
 <!-- Description -->
 wiliot-certificate is a Python library that provides tools for testing and certifying boards for compatibility with Wiliot’s ecosystem.
@@ -8,30 +8,27 @@ This python package includes the following tools:
  - Tester Upgrade (`wlt-cert-tester-upgrade`)
  - Registration Certificate (`wlt-cert-reg`)
 
-# Version: 
-wiliot-certificate versions 4.5.0 are compatible with firmware version >=4.5.0 (API VERSION: 13)
+# Versioning: 
+wiliot-certificate versions 4.5.x are compatible with firmware version >=4.5.0 (API VERSION: 13)
 
 ## Installing wiliot-certificate
-Install wiliot-certificate:
 ````commandline
 pip install wiliot-certificate
 ````
 
 ## Using wiliot-certificate
 ### Certification
-In terminal, run:
 ````commandline
 wlt-cert
 ````
 This tool is the default to test and certify your device.
 It runs a setup wizard that walks you through the initialization steps before running the tests.
-You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file ([more info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)).
+You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file (more info [here](https://community.wiliot.com/customers/s/article/Wiliot-Certification)).
 Once set up it opens a terminal and tests your device.
 
 
 
 ### Certificate CLI
-In terminal, run:
 ````commandline
 wlt-cert-cli -h
 ````
@@ -39,7 +36,6 @@ CLI version of the certificate. Use -h for details on the different arguments.
 
 
 ### Tester Upgrade
-In terminal, run:
 ````commandline
 wlt-cert-tester-upgrade
 ````
@@ -47,13 +43,12 @@ Upgrades the firmware of the tester device to the version required for certifica
 
 
 ### Registration Certificate
-In terminal, run:
 ````commandline
 wlt-cert-reg
 ````
 Certify the gateway registration process to Wiliot platform.
 The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
-Use -h for details on the arguments. [More info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)
+Use -h for details on the arguments (see [Registration](https://community.wiliot.com/customers/s/article/Wiliot-Certification) for more info).
 
 
 ## The following capabilities are not tested in this version

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "wiliot_certificate"
-version = "4.5.0a2"
+version = "4.5.0a4"
 authors = [
   { name="Wiliot", email="support@wiliot.com" }
 ]
@@ -54,7 +54,7 @@ exclude = ["*.ut*"]
 
 [tool.setuptools.package-data]
 common = ["wlt_logo.png", "**/*.html", "**/*.json"]
-certificate = ["**/*.json", "**/*.md", "*_list.txt", "**/wlt_cmd_if.html", "**/wlt_types.html"]
+certificate = ["tests/**/*.json", "*_list.txt", "**/wlt_cmd_if.html"]
 gui_certificate = ["**/*.html"]
 
 [tool.setuptools.exclude-package-data]

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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
@@ -606,8 +604,8 @@ def run_event_test_phase(test, phase, datapath_module, values, scan_time, event_
         scan_time_multiplier = (1 / 3)
         fields += [BRG_RSSI_MOVEMENT_THRESHOLD]
 
-    test = (cert_config.brg_configure_ble5(test, fields=fields, values=values, module=datapath_module)[0] if ble5_test
-            else cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module)[0])
+    ble5 = ble5_test and test.dut_is_bridge()  # ble5 only for bridge dut (with combo we don't need to wait)
+    test = cert_config.brg_configure(test, fields=fields, values=values, module=datapath_module, ble5=ble5)[0]
     test.set_phase_rc(phase, test.rc)
     test.add_phase_reason(phase, test.reason)
     if test.rc == TEST_FAILED and test.exit_on_param_failure:
@@ -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])

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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)
@@ -313,14 +315,14 @@ def brg_configure_ble5(test, cfg_pkt=None, module=None, fields=None, values=None
     if wait is False:
         return test, DONE
     while not pkts_found:
-        if ((datetime.datetime.now() - start_time).seconds > ((ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1)):
+        if ((datetime.datetime.now() - start_time).seconds > BLE5_MAX_DURATION_SEC):
             if num_of_tries < 3:
                 num_of_tries += 1
                 start_time = datetime.datetime.now()
                 gw_downlink(test=test, raw_tx_data=cfg_pkt.dump(), max_duration=BLE5_MAX_DURATION_MS, max_retries=BLE5_MAX_RETRIES, target=target)
-                print(f"Brg configure - BLE5 mode : No pkts found after {(ag.BLE5_PARAM_PRIMARY_CHANNEL_SCAN_CYCLE/1000)+1} seconds, in try number {num_of_tries}")
+                print(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in try number {num_of_tries}")
             else:
-                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_MS} seconds, in 3 tries")
+                test.add_reason(f"Brg configure - BLE5 mode : No pkts found after {BLE5_MAX_DURATION_SEC} seconds, in 3 tries")
                 test.rc = TEST_FAILED
                 time.sleep(1)
                 mqttc.flush_pkts()
@@ -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
 

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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)]

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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)
 

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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):

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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,

{wiliot_certificate-4.5.0a2 → wiliot_certificate-4.5.0a4}/src/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]