wiliot-certificate 4.4.2__py3-none-any.whl → 4.5.0__py3-none-any.whl

{brg_certificate → certificate}/tests/calibration/pattern_test/pattern_test.py

@@ -1,8 +1,10 @@
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
-from brg_certificate.wlt_types import *
-import brg_certificate.cert_common as cert_common
-import brg_certificate.cert_config as cert_config
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_data_sim as cert_data_sim
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
 
 
 def run(test):
@@ -17,10 +19,13 @@ def run(test):
 
     for param in test.params:
         # A special verification for 38_38_39, which is irrelevant for bridge with cloud connectivity
-        if param.value == ag.CALIBRATION_PATTERN_38_38_39 and not cert_common.is_bcc_running(test):
+        if param.value == ag.CALIBRATION_PATTERN_38_38_39 and not test.dut_is_combo():
             utPrint("\nCALIBRATION_PATTERN_38_38_39 was configured - checking the GW doesn't receive tag packets", "BLUE")
-            # Config internal_brg's rx_channel to CHANNEL_37
-            test = cert_config.internal_brg_configure(test, fields=[BRG_RX_CHANNEL], values=[ag.RX_CHANNEL_37], module=datapath_module)[0]
+            # Config tester's rx_channel to CHANNEL_37
+            test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL],
+                                             values=[ag.RX_CHANNEL_37],
+                                             module=test.tester.internal_brg.datapath,
+                                             target=TESTER)[0]
             if test.rc != TEST_FAILED:
                 # Configure the BRG, wait=False
                 test = cert_config.brg_configure(test, fields=[BRG_PATTERN, BRG_CALIB_INTERVAL],
@@ -31,7 +36,7 @@ def run(test):
                     else:
                         test.reset_result()  # reset result
                         continue  # skip the current phase and continue to next param
-                cert_common.wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
+                wait_time_n_print(CLEAR_DATA_PATH_TIMEOUT)
                 # MQTT scan
                 if test.data == DATA_SIMULATION:
                     # start generating pkts and send them using data simulator
@@ -44,16 +49,16 @@ def run(test):
                     time.sleep(5)
 
                 # Analyze pass/fail
-                gw_tags_pkts = len(df.query('src_id == gw_id'))
-                brg_tags_pkts = len(df.query('src_id != gw_id'))
+                gw_tags_pkts = len(df.query(f'src_id == {GW_ID}'))
+                brg_tags_pkts = len(df.query(f'src_id != {GW_ID}'))
                 print(f"Found gw_tags_pkts={gw_tags_pkts}, brg_tags_pkts={brg_tags_pkts}")
                 if (gw_tags_pkts == 0 and test.data == DATA_REAL_TAGS) or brg_tags_pkts != 0:
                     test.rc = TEST_FAILED
                     test.add_reason(f"gw_tags_pkts={gw_tags_pkts} brg_tags_pkts={brg_tags_pkts} for BRG 38,38,39 calibration, "
                                     "and GW scanning on ch 37")
-            # Revert internal_brg
-            test = cert_config.internal_brg_configure(test, module=datapath_module)[0]
-            generate_log_file(test, param.name)
+            # Revert tester
+            test = cert_config.brg_configure(test, module=test.tester.internal_brg.datapath, target=TESTER)[0]
+            cert_mqtt.generate_log_file(test, param.name)
             field_functionality_pass_fail_print(test, fields[0], value=param.name)
             test.set_phase_rc(param.name, test.rc)
             test.add_phase_reason(param.name, test.reason)
@@ -63,7 +68,7 @@ def run(test):
             test.reset_result()  # reset result and continue to next param
         else:
             test = cert_config.brg_configure(test, fields=fields, values=[param.value], module=calib_module)[0]
-            generate_log_file(test, param.name)
+            cert_mqtt.generate_log_file(test, param.name)
             field_functionality_pass_fail_print(test, fields[0], value=param.name)
             test.set_phase_rc(param.name, test.rc)
             test.add_phase_reason(param.name, test.reason)

certificate/tests/cloud_connectivity/acl_ext_adv_test/acl_ext_adv_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Access Control List using Extended Advertising",
+    "module": "Cloud Connectivity",
+    "purpose": "Test the access control list (ACL) functionality, configure allow list and deny list and test the behavior, while the Bridge is transmitting in extended advertising",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network---Gateway-Extended-Advertising-Implementation",
+    "initialCondition": "Gateway configured to defaults",
+    "procedure": ["Test prolog", "configure the brg to be on the deny list", "configure the brg to be on the allow list", "Test epilog"],
+    "expectedOutcome": "For the deny list - no unified packets are found, for the allow list - unified packets are found",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 206,
+    "allSupportedValues": ["deny", "allow"]
+}

certificate/tests/cloud_connectivity/acl_ext_adv_test/acl_ext_adv_test.py

@@ -0,0 +1,140 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_data_sim as cert_data_sim
+from certificate.ag.wlt_types_ag import *
+import certificate.cert_gw_sim as cert_gw_sim
+
+
+# DEFINES
+DUPLICATES = 5
+DELAY = 20
+test_indicator = cert_data_sim.PIXEL_SIM_INDICATOR
+
+
+def generate_expected_pkts(acl_bridge_ids, non_acl_bridge_id, pixels_pkts, mgmt_pkts):
+    expected_pkts_allow, expected_pkts_deny = [], []
+    # This payload is hardcoded in !ble_sim_ext_adv when adding extra data packets after mgmt packets
+    extra_data_payload = "1E16C6FC000039019F8BB88B5EE6CB0F5760B70AA55C87A494776400000000" * 5
+
+    for pkt in pixels_pkts:
+        brg_id = cert_common.change_endianness(pkt.adva)
+        (expected_pkts_allow if brg_id in acl_bridge_ids else expected_pkts_deny).append(brg_id + pkt.payload * 7)
+    for pkt in mgmt_pkts:
+        brg_id = cert_common.change_endianness(pkt.adva)
+        if brg_id in acl_bridge_ids:
+            expected_pkts_allow.append(brg_id + pkt.payload * 2 + extra_data_payload)
+            expected_pkts_deny.append(brg_id + pkt.payload * 2)
+        elif brg_id == non_acl_bridge_id:
+            expected_pkts_allow.append(brg_id + pkt.payload * 2)
+            expected_pkts_deny.append(brg_id + pkt.payload * 2 + extra_data_payload)
+    return expected_pkts_allow, expected_pkts_deny
+
+
+def run(test):
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 1', TESTER)
+
+    # Generate management and data packets
+    pixels_pkts, bridge_ids = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=100, num_of_brgs=4,
+                                                        pkt_type=PIXELS_PKT, indicator=test_indicator)
+    mgmt_pkts, _ = cert_data_sim.brg_pkt_gen(num_of_pkts_per_brg=100, num_of_brgs=4, 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]
+    non_acl_bridge_id = bridge_ids[3]
+
+    expected_pkts_allow, expected_pkts_deny = generate_expected_pkts(acl_bridge_ids, non_acl_bridge_id, pixels_pkts, mgmt_pkts)
+
+    for param in test.params:
+        phase_run_print(f"ACL Extended Advertising Test - Mode: {param.value}")
+
+        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)
+        print_update_wait(1)
+
+        test.get_mqttc_by_target(DUT).flush_pkts()
+
+        # We provide the tester with the first pkt only. It concatenates the packets to an aggregated packet.
+        for pkt in mgmt_pkts:
+            # Here the aggregated packet is 2 mgmt pkts and 5 hardcoded data pkts
+            cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_EXT_ADV} {pkt.get_pkt()} {DUPLICATES} '
+                                        f'{OUTPUT_POWER_2_4_MAX} {DELAY} {1} {1}', TESTER)
+            print_update_wait(0.1)
+        for pkt in pixels_pkts:
+            cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_EXT_ADV} {pkt.get_pkt()} {DUPLICATES} '
+                                        f'{OUTPUT_POWER_2_4_MAX} {DELAY}', TESTER)
+            print_update_wait(0.1)
+        print_update_wait(1)
+
+        cert_mqtt.dump_pkts(test, log=param.name)
+
+        # Analyze pass/fail
+        # Get all received aggregated packets with the test indicator
+        received_pkts = cert_mqtt.get_all_aggregated_data_pkts(test.get_mqttc_by_target(DUT), indicator=test_indicator)
+
+        # Validate that received packets match expected packets
+        expected_pkts = set(expected_pkts_deny if param.value == ACL_DENY else expected_pkts_allow)
+        for p in received_pkts:
+            pkt = p[ALIAS_BRIDGE_ID] + p[AGGREGATED_PAYLOAD]
+            if pkt not in expected_pkts:
+                test.rc = TEST_FAILED
+                test.add_reason(f"Phase failed! Received unexpected packet from brg {p[ALIAS_BRIDGE_ID]} in {param.value} mode")
+                break
+
+        # Filter packets by bridge IDs in ACL list
+        received_data_pkts = [pkt for pkt in received_pkts if MGMT_PKT not in pkt]
+        acl_bridge_pkts = [pkt for pkt in received_data_pkts if pkt[ALIAS_BRIDGE_ID] in acl_bridge_ids]
+        non_acl_bridge_pkts = [pkt for pkt in received_data_pkts if pkt[ALIAS_BRIDGE_ID] == non_acl_bridge_id]
+
+        # In deny mode - we want to make sure bridges in ACL list are filtered
+        if param.value == ACL_DENY:
+            if len(non_acl_bridge_pkts) == 0:
+                test.rc = TEST_FAILED
+                test.add_reason(f"Phase failed! Bridge {non_acl_bridge_id} was not in the deny list "
+                                f"and packets were not found from it")
+            if len(acl_bridge_pkts) != 0:
+                test.rc = TEST_FAILED
+                test.add_reason("Phase failed! Received packets from bridges that were on the deny list")
+
+        # In allow mode - we want to make sure only bridges in ACL list are not filtered
+        if param.value == ACL_ALLOW:
+            if len(non_acl_bridge_pkts) != 0:
+                test.rc = TEST_FAILED
+                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):
+                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])
+        if not set(bridge_ids).issubset(mgmt_bridge_ids):
+            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}")
+
+        field_functionality_pass_fail_print(test, "ACL", value=param.value)
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            break
+        else:
+            test.reset_result()
+
+    cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
+    return cert_common.test_epilog(test, revert_gws=True)

certificate/tests/cloud_connectivity/acl_test/acl_test.json

@@ -0,0 +1,15 @@
+{
+    "name": "Access Control List",
+    "module": "Cloud Connectivity",
+    "purpose": "Test the access control list (ACL) functionality, configure allow list and deny list and test the behavior",
+    "documentation": "https://community.wiliot.com/customers/s/article/Access-Control-List",
+    "initialCondition": "Gateway configured to defaults",
+    "procedure": ["Test prolog", "configure the brg to be on the deny list", "configure the brg to be on the allow list", "Test epilog"],
+    "expectedOutcome": "For the deny list - no unified packets are found, for the allow list - unified packets are found",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 205,
+    "allSupportedValues": ["deny", "allow"]
+}

certificate/tests/cloud_connectivity/acl_test/acl_test.py

@@ -0,0 +1,96 @@
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+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
+
+
+def run(test):
+
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    # Generate management and data packets
+    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=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]
+    non_acl_bridge_id = bridge_ids[3]
+    pkts = pixels_pkts + mgmt_pkts
+
+    sim_thread = cert_data_sim.GenericSimThread(test=test, pkts=pkts)
+    sim_thread.start()
+
+    for param in test.params:
+        phase_run_print(f"ACL Test - Mode: {param.value}")
+        test.flush_all_mqtt_packets()
+
+        cfg = cert_config.get_default_gw_dict(test)
+        cfg[ACL][ACL_BRIDGE_IDS] = acl_bridge_ids
+        cfg[ACL][ACL_MODE] = param.value
+        test, _ = cert_config.gw_configure(test, cfg=cfg, wait=True)
+        print_update_wait(1)
+
+        test.get_mqttc_by_target(DUT).flush_pkts()
+        mqtt_scan_wait(test, SCAN_TIMEOUT)
+        cert_mqtt.dump_pkts(test, log=param.name)
+
+        # 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 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:
+            if len(non_acl_bridge_pkts) == 0:
+                test.rc = TEST_FAILED
+                test.add_reason(f"Phase failed! Bridge {non_acl_bridge_id} was not in the deny list "
+                                f"and packets were not found from it")
+            if len(acl_bridge_pkts) != 0:
+                test.rc = TEST_FAILED
+                test.add_reason("Phase failed! Received packets from bridges that were on the deny list")
+
+        # In allow mode - we want to make sure only bridges in ACL list are not filtered
+        if param.value == ACL_ALLOW:
+            if len(non_acl_bridge_pkts) != 0:
+                test.rc = TEST_FAILED
+                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_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_alias_bridge_ids = set([pkt[ALIAS_BRIDGE_ID] for pkt in all_mgmt_pkts])
+
+        if len(mgmt_alias_bridge_ids) != NUM_OF_BRGS:
+            test.rc = TEST_FAILED
+            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)
+        test.add_phase_reason(param.name, test.reason)
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            break
+        else:
+            test.reset_result()
+
+    sim_thread.stop()
+    return cert_common.test_epilog(test, revert_gws=True, modules=[])

certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.json

@@ -0,0 +1,19 @@
+{
+    "name": "Bridge OTA",
+    "module": "Cloud Connectivity",
+    "purpose": "Verify the device can perform bridge firmware upgrade over the air",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Bridge-OTA"],
+    "initialCondition": "Gateway online, with bridgeOtaUpgradeSupported and in current latest version",
+    "procedure": ["Test prolog",
+                  "Publish an OTA action to the gateway",
+                  "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": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "internalBridge": 1,
+    "SupportedFromApiVersion": 203,
+    "allSupportedValues": []
+
+}

certificate/tests/cloud_connectivity/brg_ota_test/brg_ota_test.py

@@ -0,0 +1,41 @@
+
+from certificate.cert_prints import *
+from certificate.cert_defines import *
+from certificate.wlt_types import *
+from certificate.cert_utils import TESTER_FW_VERSIONS
+import certificate.cert_gw_sim as cert_gw_sim
+import certificate.cert_common as cert_common
+import certificate.cert_config as cert_config
+import certificate.cert_mqtt as cert_mqtt
+
+BRG_OTA_HIGH_TIMEOUT = (60 * 10)
+
+
+def run(test):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    phase_run_print("BRG OTA started")
+    utPrint("Important: For the gateway to be able to download the file, it must use a valid token in the HTTP GET request.", "WARNING")
+    utPrint("Meaning It must be registered under an owner, and the certificate '-env' should correspond to that owner.", "WARNING")
+    test.flush_all_mqtt_packets()
+    target_brg = test.tester.internal_brg
+    desired_ver = TESTER_FW_VERSIONS[0] if target_brg.version != TESTER_FW_VERSIONS[0] else TESTER_FW_VERSIONS[1]
+
+    # Initiate action
+    utPrint(f"Publishing OTA action to DUT: {test.dut.mqttc.update_topic}. Awaiting OTA.. (timeout is {BRG_OTA_HIGH_TIMEOUT} seconds)")
+    # Set active_brg to be the tester, for reboot_config_analysis within brg_ota
+    test.active_brg = target_brg
+    test = cert_config.brg_ota(test, ble_version=desired_ver, search_ack=True, target=TESTER, upgrader=DUT, timeout=BRG_OTA_HIGH_TIMEOUT)
+
+    # Stop advertising on tester in case it just rebooted after getting OTA. So it is ready for next tests
+    cert_config.gw_action(test, cert_gw_sim.STOP_ADVERTISING, target=TESTER)
+
+    cert_mqtt.generate_log_file(test, "brg_ota")
+
+    if test.rc == TEST_PASSED and cert_gw_sim.GW_SIM_RESET_TS is not None:
+        reboot_pkt_time = int((cert_gw_sim.GW_SIM_RESET_TS - test.start_time).total_seconds())
+        test.reason = f"Reboot pkt received after {reboot_pkt_time} seconds"
+
+    return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.json

@@ -0,0 +1,19 @@
+{
+    "name": "Gateway Channel behavior",
+    "module": "Cloud Connectivity",
+    "purpose": "Test gateway's channel scanning time cycles on all main channels",
+    "documentation": "",
+    "initialCondition": "Gateway configured with default settings",
+    "procedure": ["Test prolog",
+                  "Send packets as close as possible to continuously on all 3 channels, with a unique channel identifier",
+                  "Scan for packets and identify scanning behaviour",
+                  "Test epilog"],
+    "expectedOutcome": "There is no expected outcome from the GW (Only behaviour analysis)",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "internalBridge": 1,
+    "SupportedFromApiVersion": 203,
+    "allSupportedValues": []
+}

certificate/tests/cloud_connectivity/channel_scan_behaviour_test/channel_scan_behaviour_test.py

@@ -0,0 +1,215 @@
+from certificate.cert_prints import *
+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_mqtt as cert_mqtt
+import certificate.cert_config as cert_config
+import certificate.cert_gw_sim as cert_gw_sim
+import os
+import math
+import pandas as pd
+import plotly.express as px
+import time
+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 = 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
+BLE_SIM_SINGLE_UNIQUE_PKT = 1
+SCAN_DUPLICATES = 1
+BLE_SIM_ADV_37_38_39 = 0
+UNIQUE_CONTENT = 1
+PPS = 20
+
+# HELPER FUNCTIONS
+
+
+def interpolation(payload, next_payload, channel_pkt_counter):
+    cur_pkt_num = int.from_bytes(bytes.fromhex(payload[-8:]), byteorder="little")
+    next_pkt_num = int.from_bytes(bytes.fromhex(next_payload[-8:]), byteorder="little")
+    diff = next_pkt_num - cur_pkt_num
+    if diff > 1:
+        channel_pkt_counter += diff - 1
+    return channel_pkt_counter
+
+
+def compute_channels_windows(timeline_df):
+    """
+    Build contiguous channel windows: for each run of the same channel, return (channel, start_ts, end_ts).
+    The result is and array of these windows. For exmaple: [(37, 0.004), (38, 0.038), .....]
+    """
+    windows = []
+    current_ch = timeline_df.iloc[0]['channel']
+    start_ts = timeline_df.iloc[0]['timestamp_ms']
+
+    for _, row in timeline_df.iloc[1:].iterrows():
+        if row['channel'] != current_ch:
+            windows.append((current_ch, start_ts))
+            current_ch = row['channel']
+            start_ts = row['timestamp_ms']
+
+    windows.append((current_ch, start_ts))
+    return windows
+
+
+def compute_listening_stats(windows):
+    per_channel_starts = defaultdict(list)
+    avg_start_to_start_ms = {}
+
+    for ch, start_ts in windows:
+        per_channel_starts[ch].append(start_ts)
+
+    # Calculating the avg for each channel of the compelte cycle it does (that inclues all channels listend to)
+    for ch in CHANNELS:
+        starts = sorted(per_channel_starts.get(ch, []))
+        start_gaps = [curr - prev for prev, curr in zip(starts, starts[1:])]
+        avg_start_to_start_ms[ch] = sum(start_gaps) / len(start_gaps) if start_gaps else 0
+
+    return avg_start_to_start_ms
+
+
+def analyze_listening_timeline(test, all_pkts_received_from_tester, num_of_sent_pkts, start_timestamp_ms):
+    """
+    Build a timeline graph and print channel listening percentages.
+    """
+    timeline_entries = []
+    channel_pkt_counter = defaultdict(int)
+    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)
+        time_stamp = float(pkt.get(TIMESTAMP))
+
+        # Add dropped packts in the middle of listening windows to neglect it from not scanning window
+        # Those complitions will not apear in the graph, only on % calculations
+        # If there are packets dropped at the ed of a window - it can not detect that
+        if idx < len(all_pkts_received_from_tester) - 1:
+            next_pkt = all_pkts_received_from_tester[idx + 1]
+            next_channel = int(next_pkt.get(PAYLOAD)[-10:-8], 16)
+            if next_channel == channel:
+                next_payload = next_pkt.get(PAYLOAD)
+                channel_pkt_counter[channel] = interpolation(payload, next_payload, channel_pkt_counter[channel])
+
+        timeline_entries.append({'timestamp_ms': time_stamp, 'channel': channel})
+        channel_pkt_counter[channel] += 1
+
+    if not timeline_entries or not channel_pkt_counter:
+        utPrint("No packets were received; skipping timeline graph", "RED")
+        test.rc = TEST_FAILED
+        test.reason = "No packets were received in all channels"
+        return
+
+    # Create graph
+    timeline_df = pd.DataFrame(timeline_entries).sort_values('timestamp_ms')
+    timeline_df['relative_time_s'] = (timeline_df['timestamp_ms'] - start_timestamp_ms) / 1000
+    timeline_path = os.path.join(ARTIFACTS_DIR, test.dir, 'channel_scan_behavior.html')
+    color_map = {37: "#1f77b4", 38: "#ff7f0e", 39: "#2ca02c"}
+    timeline_fig = px.scatter(timeline_df, x='relative_time_s', y='channel', color='channel', color_discrete_map=color_map,
+                              title='Channel scanning timeline',
+                              labels={'relative_time_s': 'Time (s)', 'channel': 'Scanning Channel'})
+    timeline_fig.update_layout(height=350, yaxis=dict(tickmode='array', tickvals=CHANNELS, ticktext=[str(ch) for ch in CHANNELS],
+                               range=[min(CHANNELS) - 0.5, max(CHANNELS) + 0.5]))
+    timeline_fig.update_coloraxes(showscale=False)
+
+    # Build contiguous channel windows and compute averages
+    windows = compute_channels_windows(timeline_df[['timestamp_ms', 'channel']])
+    avg_start_to_start_ms = compute_listening_stats(windows)
+    positive_start_gaps = [v for v in avg_start_to_start_ms.values() if v > 0]
+    avg_cycle_from_starts_ms = sum(positive_start_gaps) / len(positive_start_gaps) if positive_start_gaps else None
+
+    # Build per-channel cards for the HTML summary
+    for ch in CHANNELS:
+        pct_recievied_vs_sent = channel_pkt_counter[ch] * 100 / num_of_sent_pkts
+        cycle_ms = int(avg_start_to_start_ms[ch]) if int(avg_start_to_start_ms[ch]) != 0 else None
+        duration_ms = int(pct_recievied_vs_sent * cycle_ms / 100) if cycle_ms else None
+        # pct_recievied_vs_sent: packets on this channel / sent; cycle_ms: avg start-to-start; duration_ms: pct_recievied_vs_sent * cycle
+        channel_cards.append({"title": f"Channel {ch}",
+                              "pct_recievied_vs_sent": round(pct_recievied_vs_sent, 4),
+                              "cycle_ms": cycle_ms,
+                              "duration_ms": duration_ms})
+
+    # Not‑scanning stats are the residual to 100% after the three channels
+    # Interpolation smooths dropouts so this reflects actual not-scannning time
+    observed_pct_recievied_vs_sent = sum(card["pct_recievied_vs_sent"] for card in channel_cards)
+    channel_cards.append({"title": "Not scanning",
+                          "pct_recievied_vs_sent": max(0, round(100 - observed_pct_recievied_vs_sent, 2)),
+                          "cycle_ms": int(avg_cycle_from_starts_ms) if avg_cycle_from_starts_ms else None,
+                          "duration_ms": int((max(0, round(100 - observed_pct_recievied_vs_sent, 2)) *
+                                              (int(avg_cycle_from_starts_ms) if avg_cycle_from_starts_ms else 0)) / 100)
+                          if avg_cycle_from_starts_ms else None})
+
+    # Embed summary text into the HTML alongside the plot
+    cards_html = "".join([
+        (
+            "<div style='flex:1; min-width:200px; border:1px solid #ddd; border-radius:8px; padding:12px; background:#fafafa;'>"
+            f"<div style='font-weight:700; margin-bottom:8px;'>{card['title']}</div>"
+            f"<div>% scanning: {card['pct_recievied_vs_sent']}% </div>"
+            f"<div>Scan cycle: {card['cycle_ms']} ms </div>"
+            f"<div>Scan duration: {card['duration_ms']} ms </div>"
+            "</div>"
+        )
+        for card in channel_cards
+    ])
+    summary_html = (
+        "<div style=\"font-family: Arial, sans-serif; font-size:16px; line-height:1.5; margin-bottom:16px;\">"
+        f"<h3 style=\"margin:0 0 8px 0;\">Scan Summary</h3>"
+        f"<div style='display:flex; gap:12px; margin-top:12px; flex-wrap:wrap;'>{cards_html}</div>"
+        "</div>"
+    )
+    full_html = f"<html><head></head><body>{summary_html}{timeline_fig.to_html(full_html=False, include_plotlyjs='cdn')}</body></html>"
+    with open(timeline_path, "w") as f:
+        f.write(full_html)
+
+
+def run(test):
+    test = cert_common.test_prolog(test)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test)
+
+    # Setup
+    phase_run_print("Running scan channel behavior")
+    all_messages_in_test = []
+    all_data_pkts = []
+    all_data_pkts_from_tester = []
+
+    # Prepairation for advertisment
+    cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 1', TESTER)  # Move BLE to sim mode
+    delay = math.floor(1000 / PPS)
+    upload_wait_time = test.dut.upload_wait_time + DEFAULT_WAIT_TIME
+    payload = cert_common.generate_adv_payload(SCAN_TEST_INDICATOR, unique_pkt=True)
+
+    # Transmitting packets on all channels
+    utPrint(f"Transmitting in parallel on all 3 main channels for {ADV_DURATION} seconds", "WARNING")
+    num_of_sent_pkts = ADV_DURATION * PPS
+    strat_trans_time_ms = time.time() * 1000
+
+    cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM} '
+                          f'{payload} {SCAN_DUPLICATES} {OUTPUT_POWER_2_4_MAX} '
+                          f'{BLE_SIM_ADV_37_38_39} {delay} {BLE_SIM_RADIO_1MBPS} {num_of_sent_pkts} {BLE_SIM_SINGLE_UNIQUE_PKT}',
+                          TESTER)
+    mqtt_scan_wait(test, ADV_DURATION + upload_wait_time)
+
+    all_data_pkts_from_tester.extend(cert_mqtt.get_all_data_pkts(test.get_mqttc_by_target(DUT), indicator=SCAN_TEST_INDICATOR))
+    all_data_pkts.extend(cert_mqtt.get_all_data_pkts(test.get_mqttc_by_target(DUT)))
+    all_messages_in_test.extend(test.get_mqttc_by_target(DUT)._userdata[PKTS].data)
+
+    cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
+    time.sleep(1)  # To allow all packets to show in the log
+
+    cert_mqtt.generate_log_file(test, 'channel_scan', target=DUT)
+    cert_mqtt.generate_log_file(test, 'channel_scan_tester', target=TESTER)
+
+    analyze_listening_timeline(test, all_data_pkts_from_tester, num_of_sent_pkts, strat_trans_time_ms)
+
+    test = cert_common.wiliot_pkts_validation(test, all_messages_in_test, all_data_pkts)
+
+    return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/connection_test/connection_test.json

@@ -0,0 +1,18 @@
+{
+    "name": "Gateway Connection",
+    "module": "Cloud Connectivity",
+    "purpose": "Verify that the device uploads its status message to the MQTT status topic upon connecting to the MQTT, after manual disconnect",
+    "documentation": ["https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud"],
+    "initialCondition": "Device is connected to MQTT and ready at hand to be manually turned off",
+    "procedure": ["Test prolog",
+                  "Disconnect sequence - Device gets powered off and then on according to the instructions",
+                  "Wait for device to connect to MQTT by verifying a status message or fail when timeout occurs",
+                  "Test epilog"],
+    "expectedOutcome": "Device reconnects and publishes its configuration to the MQTT status topic before timeout",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "SupportedFromApiVersion": 203,
+    "allSupportedValues": []
+
+}