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

certificate/tests/cloud_connectivity/connection_test/connection_test.py

@@ -25,19 +25,10 @@ def run(test):
     if not cert_common.pipeline_running():
         warning_prefix = COLORS["WARNING"]
         warning_suffix = COLORS["ENDC"]
-        input(
-            (
-                f"{warning_prefix}The GW is expected to publish a configuration "
-                "JSON/Protobuf message through the status topic upon connecting "
-                "to mqtt:\nPlease unplug GW from power. Press enter when unplugged"
-                f"{warning_suffix}"
-            )
-        )
         dut_mqttc.flush_pkts()
-        input(
-            f"{warning_prefix}Please plug GW back to power. "
-            f"Press enter when plugged{warning_suffix}"
-        )
+        input((f'{warning_prefix}TESTING CONNECTION RECOVERY AFTER POWER CYCLE OF THE GATEWAY\n'
+               "Please unplug and then plug GW back into power. Press enter when finished"
+               f"{warning_suffix}"))
     else:
         # If this test runs as part of a pipeline, act like the reboot test and don't demand a manual disconnect & connect
         utPrint(f"Publishing reboot action to {dut_mqttc.update_topic}. Awaiting reconnect.. (timeout is {TIMEOUT_IN_MINUTES} minutes)")
@@ -55,7 +46,7 @@ def run(test):
         print_update_wait(5)
 
     # generate logs
-    cert_mqtt.generate_log_file(test, "reboot")
+    cert_mqtt.generate_log_file(test, "connection")
 
     # Analyze results
     if gw_type is None:

certificate/tests/cloud_connectivity/deduplication_test/deduplication_test.py

@@ -3,14 +3,13 @@ from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_data_sim as cert_data_sim
 import pandas as pd
 
 
 # DEFINES
-UPLINK_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+UPLINK_TEST_INDICATOR = get_random_hex_str(6)
 NUM_OF_BRGS = 3
 
 

certificate/tests/cloud_connectivity/ext_adv_stress_test/ext_adv_stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+STRESS_TEST_INDICATOR = get_random_hex_str(6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -76,16 +76,19 @@ def run(test):
 
         cert_mqtt.dump_pkts(test, log=str(pps))
         phase_pkts_received = cert_mqtt.get_all_aggregated_data_pkts(test.get_mqttc_by_target(DUT), indicator=STRESS_TEST_INDICATOR)
-
+        valid, reason = cert_common.validate_received_packets(phase_pkts_received)
+        test.add_phase(cert_utils.Phase(pps))
+        if valid is False:
+            test.set_phase_rc(str(pps), TEST_FAILED)
+            test.add_phase_reason(str(pps), reason)
+            utPrint(f"Phase {pps} failed validation: {reason}", "RED")
+            continue
         test, received_pps = cert_common.stress_analysis(
             test, pps, generated_payloads,
             [(p[ALIAS_BRIDGE_ID] + p[AGGREGATED_PAYLOAD]) for p in phase_pkts_received])
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 
-        test.add_phase(cert_utils.Phase(pps))
-        test.set_phase_rc(str(pps), test.rc)
-        test.add_phase_reason(str(pps), test.reason)
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
@@ -94,6 +97,9 @@ def run(test):
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
 
     # Generate stress test graphs
-    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    if len(data_pkts_received) > 0:
+        cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    else:
+        utPrint("No data packets received - skipping graph generation", "RED")
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/registration_test/registration_test_cli.py

@@ -77,7 +77,7 @@ def main():
     cert_common.wait_time_n_print(2)
 
     # Print results
-    cert_results.generate_results_files(test.dut, test.tester, html=True, pdf=True, failures=failures,
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures,
                                         skipped=skipped, start_time=start_time, tests=tests)
     if not pipeline_running():
         webbrowser.open('file://' + os.path.realpath(os.path.join(ARTIFACTS_DIR, UT_RESULT_FILE_PDF)))

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -12,7 +12,7 @@ import math
 
 
 # DEFINES
-STRESS_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+STRESS_TEST_INDICATOR = get_random_hex_str(6)
 
 DUPLICATES = 1
 ADVA_ASCII_LEN = 12
@@ -74,16 +74,19 @@ def run(test):
 
         cert_mqtt.dump_pkts(test, log=str(pps))
         phase_pkts_received = cert_mqtt.get_all_data_pkts(test.get_mqttc_by_target(DUT), indicator=STRESS_TEST_INDICATOR)
-
+        test.add_phase(cert_utils.Phase(pps))
+        valid, reason = cert_common.validate_received_packets(phase_pkts_received)
+        if valid is False:
+            test.set_phase_rc(str(pps), TEST_FAILED)
+            test.add_phase_reason(str(pps), reason)
+            utPrint(f"Phase {pps} failed validation: {reason}", "RED")
+            continue
         test, received_pps = cert_common.stress_analysis(
             test, pps, generated_payloads,
             [(p[ALIAS_BRIDGE_ID] + p[PAYLOAD]) for p in phase_pkts_received])
         results.extend([pps, received_pps])
         cert_mqtt.generate_log_file(test, str(pps))
 
-        test.add_phase(cert_utils.Phase(pps))
-        test.set_phase_rc(str(pps), test.rc)
-        test.add_phase_reason(str(pps), test.reason)
         if test.rc == TEST_FAILED and test.exit_on_param_failure:
             break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
@@ -91,7 +94,9 @@ def run(test):
         test_pkts_received.extend(test.get_mqttc_by_target(DUT)._userdata[PKTS].data)
     cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM_INIT} 0', TESTER)
 
-    # Generate stress test graphs
-    cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    if len(data_pkts_received) > 0:
+        cert_common.generate_graph_stress_test(test, results, data_pkts_received)
+    else:
+        utPrint("No data packets received - skipping graph generation", "RED")
 
     return cert_common.test_epilog(test)

certificate/tests/cloud_connectivity/uplink_ext_adv_test/uplink_ext_adv_test.py

@@ -4,14 +4,13 @@ from certificate.cert_prints import *
 from certificate.cert_defines import *
 from certificate.wlt_types import *
 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_data_sim as cert_data_sim
 from certificate.cert_gw_sim import GW_CERT_TESTER
 
 # DEFINES
-EXT_ADV_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+EXT_ADV_TEST_INDICATOR = get_random_hex_str(6)
 EXPECTED_REPEAT_COUNT = 7
 
 

certificate/tests/cloud_connectivity/uplink_test/uplink_test.py

@@ -4,7 +4,6 @@ from certificate.cert_defines import *
 from certificate.wlt_types import *
 from common.api_if.api_validation import api_validation
 import certificate.cert_common as cert_common
-import certificate.cert_utils as cert_utils
 import certificate.cert_mqtt as cert_mqtt
 import certificate.cert_data_sim as cert_data_sim
 import pandas as pd
@@ -13,24 +12,27 @@ import pandas as pd
 # DEFINES
 
 API_VALIDATION = "API Validation"
-UPLINK_TEST_INDICATOR = cert_utils.get_random_hex_str(len=6)
+UPLINK_TEST_INDICATOR = get_random_hex_str(6)
 NUM_OF_BRGS = 3
 
 
 # HELPER FUNCTIONS
-def uplink_analysis(test, pkts, received_pkts, pkt_type):
+def uplink_analysis(test, sent_pkts, received_pkts, pkt_type):
     if len(received_pkts) == 0:
         test.set_phase_rc(pkt_type, TEST_FAILED)
         test.add_phase_reason(pkt_type, "No packets were received!")
-        return test, 0
+        return test
 
-    _sent_pkts = []
-    for pkt in pkts:
-        pkt_str = pkt.get_pkt()
-        adva_endianness_change = cert_common.change_endianness(pkt_str[:12]) + pkt_str[12:]  # Switch to big endian adva
-        _sent_pkts.append(adva_endianness_change)
+    # Verify packets were received from NUM_OF_BRGS bridges
+    received_brgs = len(set([p[ALIAS_BRIDGE_ID] for p in received_pkts]))
+    if received_brgs != NUM_OF_BRGS:
+        test.set_phase_rc(pkt_type, TEST_FAILED)
+        test.add_phase_reason(pkt_type, f"Received packets from {received_brgs} bridges instead of {NUM_OF_BRGS} bridges!")
+        return test
 
+    _sent_pkts = [p.get_pkt()[12:] for p in sent_pkts]
     sent_df = pd.DataFrame(_sent_pkts, columns=[PACKETS])
+    received_pkts = [p[PAYLOAD] for p in received_pkts]
     received_df = pd.DataFrame(received_pkts, columns=[PACKETS])
 
     merged_df = pd.merge(sent_df, received_df, on=PACKETS, how='inner')
@@ -47,16 +49,17 @@ def uplink_analysis(test, pkts, received_pkts, pkt_type):
     if pkts_sent_count == 0:
         test.set_phase_rc(pkt_type, TEST_FAILED)
         test.add_phase_reason(pkt_type, "No packets were sent!")
-        return test, 0
+        return test
 
     percentage_received = round(pkts_received_count * 100 / pkts_sent_count)
 
     # PASS/FAIL logic
     if percentage_received < 80:
-        test.rc = TEST_FAILED
-        test.reason = f"Insufficient amount of {pkt_type} packets were scanned & uploaded by the gateway"
+        test.set_phase_rc(pkt_type, TEST_FAILED)
+        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
     else:
-        test.reason = f'{percentage_received}% of {pkt_type} packets received'
+        test.set_phase_rc(pkt_type, TEST_PASSED)
+        test.add_phase_reason(pkt_type, f'{percentage_received}% of {pkt_type} packets received')
 
     return test
 
@@ -134,22 +137,25 @@ def run(test):
         all_data_messages_in_test.extend(dut_mqttc._userdata[PKTS].data)
         all_data_pkts.extend(cert_mqtt.get_all_data_pkts(dut_mqttc))
         recieved_pkts = cert_mqtt.get_all_data_pkts(dut_mqttc, indicator=UPLINK_TEST_INDICATOR)
+        valid, reason = cert_common.validate_received_packets(recieved_pkts)
+        if valid is False:
+            test.set_phase_rc(param.name, TEST_FAILED)
+            test.add_phase_reason(param.name, reason)
+            utPrint(f"Phase {param.name} failed validation: {reason}", "RED")
+            continue
 
-        test = uplink_analysis(test, pkts, [p[ALIAS_BRIDGE_ID] + p[PAYLOAD] for p in recieved_pkts], param.name)
+        test = uplink_analysis(test, pkts, recieved_pkts, param.name)
 
         cert_mqtt.generate_log_file(test, param.name)
-        field_functionality_pass_fail_print(test, 'pkt_type', value=param.name)
-        test.set_phase_rc(param.name, test.rc)
-        test.add_phase_reason(param.name, test.reason)
-        if test.rc == TEST_FAILED:
+        field_functionality_pass_fail_print(test.get_phase_by_name(param.name), 'pkt_type', value=param.name)
+        if test.get_phase_by_name(param.name).rc == TEST_FAILED:
             if test.exit_on_param_failure:
                 break  # break the whole for loop and keep the test as failed
         test.reset_result()  # reset result and continue to next param
 
     # Other Validations
     # Api Validation
-    if not test.dut.protobuf:
-        test = api_validation(test)
+    test = api_validation(test)
     test = cert_common.wiliot_pkts_validation(test, all_data_messages_in_test, all_data_pkts)
 
     # Geolocation phase

certificate/tests/datapath/event_ble5_test/event_ble5_test.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
 }

certificate/tests/datapath/event_ble5_test/event_ble5_test.py

@@ -7,17 +7,9 @@ import certificate.cert_config as cert_config
 
 NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
 TAG_EVENT_SCAN_TIME = 60                 # in seconds
-NEW_TAG_HOURS_EVENT_SCAN_TIME = 62 * 60   # 62 minutes
 RSSI_MOVEMENT_THRESHOLD = 15
 
 
-def test_new_tag_event_hours(test, phase, datapath_module):
-    values = [ag.EVENT_TIME_UNIT_HOURS, TEST_EVENT_WINDOW_HR_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_NEW_TAG, 0]
-    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_HOURS_EVENT_SCAN_TIME,
-                                            ag.EVENT_TIME_UNIT_HOURS, ble5_test=True,
-                                            pkt_filter_cfg=ag.PKT_FILTER_TEMP_AND_ADVANCED_PKTS)
-
-
 def test_new_tag_event_minutes(test, phase, datapath_module):
     values = [ag.EVENT_TIME_UNIT_MINUTES, TEST_EVENT_WINDOW_MIN_CFG, ag.RX_CHANNEL_10_500K, ag.EVENT_TRIGGER_NEW_TAG, 0]
     return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME,
@@ -54,7 +46,7 @@ def test_rssi_event(test, phase, datapath_module):
 
 
 EVENT_TEST_MAP = {"rssi_event": test_rssi_event, "new_tag_event_seconds": test_new_tag_event_seconds,
-                  "new_tag_event_minutes": test_new_tag_event_minutes, "new_tag_event_hours": test_new_tag_event_hours,
+                  "new_tag_event_minutes": test_new_tag_event_minutes,
                   "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
 
 

certificate/tests/datapath/event_test/event_test.json

@@ -12,5 +12,5 @@
     "multiBridgeTest": 0,
     "gwOnlyTest": 0,
     "dataSimOnlyTest": 1,
-    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "new_tag_event_hours", "temp_event", "tx_rate_event"]
+    "allSupportedValues": ["rssi_event", "new_tag_event_seconds", "new_tag_event_minutes", "temp_event", "tx_rate_event"]
 }

certificate/tests/datapath/event_test/event_test.py

@@ -7,15 +7,9 @@ import certificate.cert_config as cert_config
 
 NEW_TAG_EVENT_SCAN_TIME = 100             # in seconds
 TAG_EVENT_SCAN_TIME = 60                 # in seconds
-NEW_TAG_HOURS_EVENT_SCAN_TIME = 62 * 60   # 62 minutes
 RSSI_MOVEMENT_THRESHOLD = 15
 
 
-def test_new_tag_event_hours(test, phase, datapath_module):
-    values = [ag.EVENT_TIME_UNIT_HOURS, TEST_EVENT_WINDOW_HR_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG, 0]
-    return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_HOURS_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_HOURS)
-
-
 def test_new_tag_event_minutes(test, phase, datapath_module):
     values = [ag.EVENT_TIME_UNIT_MINUTES, TEST_EVENT_WINDOW_MIN_CFG, ag.RX_CHANNEL_37, ag.EVENT_TRIGGER_NEW_TAG, 0]
     return cert_common.run_event_test_phase(test, phase, datapath_module, values, NEW_TAG_EVENT_SCAN_TIME, ag.EVENT_TIME_UNIT_MINUTES)
@@ -45,7 +39,7 @@ def test_rssi_event(test, phase, datapath_module):
 
 
 EVENT_TEST_MAP = {"rssi_event": test_rssi_event, "new_tag_event_seconds": test_new_tag_event_seconds,
-                  "new_tag_event_minutes": test_new_tag_event_minutes, "new_tag_event_hours": test_new_tag_event_hours,
+                  "new_tag_event_minutes": test_new_tag_event_minutes,
                   "temp_event": test_temp_event, "tx_rate_event": test_tx_rate_event}
 
 

certificate/tests/datapath/rx_rate_gen2_test/rx_rate_gen2_test.py

@@ -31,7 +31,7 @@ def cal_scan_time(test, delay, pacer_interval):
 
 def scan_and_compare(test, pacer_interval, delay, expected_TBC_value):
 
-    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN3)
+    pixel_sim_thread = cert_data_sim.DataSimThread(test=test, num_of_pixels=1, duplicates=3, delay=delay, pkt_types=[0], pixels_type=GEN2)
     pixel_sim_thread.start()
     test, scan_time = cal_scan_time(test, delay, pacer_interval)
     df = cert_common.data_scan(test, scan_time=scan_time, brg_data=(not test.internal_brg), gw_data=test.internal_brg)

certificate/tests/energy2400/signal_indicator_ble5_test/signal_indicator_ble5_test.py

@@ -284,7 +284,7 @@ def test_rx_tx(test):
         print(rec_sig_ind_pkts)  # TODO: logging print(debug)
 
     # Analyzing tester performance as receiver
-    utPrint(f"Analyzing DUT {tester.id_str} performance as a Transmitter\n", "BOLD")
+    utPrint(f"Analyzing DUT {dut.id_str} performance as a Transmitter\n", "BOLD")
     rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
     if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED
@@ -323,6 +323,8 @@ def run(test):
         return cert_common.test_epilog(test, revert_brgs=True,
                                        modules=[dut.datapath],
                                        ble5=test.dut_is_bridge())
+    if test.dut_is_bridge():
+        wait_time_n_print(BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to BLE5_MAX_DURATION_SEC
     # Configure TESTER to scan ble5 channel during all the test
     test = cert_config.brg_configure(test, fields=[BRG_RX_CHANNEL],
                                      values=[ag.RX_CHANNEL_10_500K],

certificate/tests/energy2400/signal_indicator_ext_adv_test/signal_indicator_ext_adv_test.py

@@ -161,6 +161,8 @@ def run(test):
     # Revert DUT and TESTER to defaults here and not in epilog
     test = cert_config.config_brg_defaults(test, modules=[dut.datapath, dut.energy2400],
                                            ble5=test.dut_is_bridge(), wait=test.dut_is_combo())[0]
+    if test.dut_is_bridge():
+        wait_time_n_print(2 * BLE5_MAX_DURATION_SEC)  # BLE5 configuration can take up to 2 * BLE5_MAX_DURATION_SEC
     if test.rc == TEST_FAILED:
         test.add_reason("Failed to revert dut to defaults")
     else:

certificate/tests/energy2400/signal_indicator_test/signal_indicator_test.py

@@ -288,7 +288,7 @@ def test_rx_tx(test):
         print(rec_sig_ind_pkts)  # TODO: logging print(debug)
 
     # Analyzing tester performance as receiver
-    utPrint(f"Analyzing DUT {tester.id_str} performance as a Transmitter\n", "BOLD")
+    utPrint(f"Analyzing DUT {dut.id_str} performance as a Transmitter\n", "BOLD")
     rec_sig_ind_pkts = cert_common.get_all_sig_ind_pkts(test=test, rx_brg=tester, tx_brg=dut)
     if cert_common.sig_ind_pkts_fail_analysis(tx_brg=dut, rx_brg=tester, cycles=NUM_OF_SCANNING_CYCLE, received_pkts=rec_sig_ind_pkts):
         test.rc = TEST_FAILED

common/api_if/api_validation.py

@@ -25,6 +25,12 @@ def api_validation(test):
         api_validation_phase.reason = "API validation is skipped for protobuf messages"
         test.add_phase(api_validation_phase)
         return test
+    elif not test.dut.gw_api_version:
+        utPrint("API validation is skipped because no API version was specified", "WARNING")
+        api_validation_phase.rc = TEST_FAILED
+        api_validation_phase.reason = "API validation is skipped because no API version was specified"
+        test.add_phase(api_validation_phase)
+        return test
     else:
         def validate_message(message: dict, msg_type=MESSAGE_TYPES.DATA.value) -> tuple[bool, str]:
             json_path = pkg_resources.resource_filename(__name__, f"{test.dut.gw_api_version}/{msg_type}.json")