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

brg_certificate/tests/edge_mgmt/leds_test/leds_test.py

@@ -1,223 +0,0 @@
-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
-
-# Tests definitions
-BRG_REBOOT_TIME = 30
-NUM_OF_LED_BLINKS_ACTION = 10
-LEDS_KEEP_ALIVE_PERIOD = 10
-LEDS_KEEP_ALIVE_BLINKS_NUM = 2
-ENERGIZING_LED_COLOR = "RED"
-BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT = {ag.BOARD_TYPE_FANSTEL_SINGLE_BAND_V0: "Green",
-                                        ag.BOARD_TYPE_FANSTEL_DUAL_BAND_V0: "Green",
-                                        ag.BOARD_TYPE_MINEW_SINGLE_BAND_V0: "Green",
-                                        ag.BOARD_TYPE_MINEW_DUAL_BAND_V0: "Blue",
-                                        ag.BOARD_TYPE_ENERGOUS_V0: "Blue",
-                                        ag.BOARD_TYPE_ENERGOUS_V1: "Blue",
-                                        ag.BOARD_TYPE_ENERGOUS_V2: "Blue",
-                                        ag.BOARD_TYPE_ENERGOUS_V3: "Blue",
-                                        ag.BOARD_TYPE_ENERGOUS_V4: "Blue",
-                                        ag.BOARD_TYPE_ERM_V0: "Blue",
-                                        ag.BOARD_TYPE_ERM_V1: "Blue",
-                                        ag.BOARD_TYPE_KOAMTAC_V0: "Green",
-                                        ag.BOARD_TYPE_MINEW_POE_V0: "Yellow"}
-
-
-# Helper functions
-def compare_versions(gw_version, brg_version):
-    # Split versions into components
-    gw_version_parts = gw_version.split('.')
-    brg_version_parts = brg_version.split('.')
-
-    # Compare each component
-    if (len(gw_version_parts) == 3 and len(brg_version_parts) == 3 and
-            gw_version_parts[0] == brg_version_parts[0] and
-            gw_version_parts[1] == brg_version_parts[1] and
-            gw_version_parts[2] == brg_version_parts[2]):
-        return True
-    else:
-        return False
-
-
-def run(test):
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test)
-
-    test.mqttc.flush_pkts()
-    # --------------------- Pre stage ------------------------------ #
-    utPrint("Pre state - Please make sure you have a registerd GW connected to the UT BRG!!!", "WARNING")
-    utPrint("Press 'y' if the GW is registered and connected to the UT BRG", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "PRE STAGE")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test)
-    utPrint("GW is registered and connected to UT BRG!", "GREEN")
-
-    # Determine LED colors according to the board type
-    test, interface = cert_common.get_module_if_pkt(test)
-    if test.rc == TEST_FAILED:
-        utPrint("Failed to get the GW interface packet!", "RED")
-        return cert_common.test_epilog(test)
-    board_type = interface.board_type
-    if board_type not in BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT:
-        utPrint(f"Unknown board type: {board_type}", "RED")
-        return cert_common.test_epilog(test)
-    else:
-        ECHOING_LED_COLOR = BOARD_TYPE_2_ECHOING_LED_COLLOR_DICT[board_type]
-    if board_type == ag.BOARD_TYPE_MINEW_POE_V0:
-        NUS_INDICATION_LED_COLOR = "Green"
-    else:
-        NUS_INDICATION_LED_COLOR = ECHOING_LED_COLOR
-
-    # Version verification
-    gw_ble_version = test.gw_orig_versions.get(BLE_VERSION)
-    bridge_ble_version = test.active_brg.version
-    if gw_ble_version and bridge_ble_version:
-        if compare_versions(gw_ble_version, bridge_ble_version) is False:
-            utPrint("Versions are not alligned - Please make sure the BLE versions are the same", "RED")
-            return cert_common.test_epilog(test)
-        else:
-            utPrint("GW & BRG versions are the same - Pre stage Passed!", "GREEN")
-    else:
-        utPrint("Failed to get the BLE versions, please try again!", "RED")
-        return cert_common.test_epilog(test)
-
-    utPrint("Starting examining the LED's, Please pay attention to the following steps!", "WARNING")
-    # ---------------------  Advertising LED  --------------------- #
-    utPrint("Advertising LED check - sending Reboot action to BRG!", "HEADER")
-    cert_config.send_brg_action(test, ag.ACTION_REBOOT)
-    reboot_start_ts = int(datetime.datetime.now().timestamp())
-    utPrint(f"The BRG was rebooted - is the advertising LED ({NUS_INDICATION_LED_COLOR}) continuously "
-            "on and all other LED's are off? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Advertising LED check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test)
-    # wait for advertisement phase to finish
-    if (int(datetime.datetime.now().timestamp()) - reboot_start_ts < BRG_REBOOT_TIME):
-        utPrint(f"Now we'll wait for the BRG to finish his {BRG_REBOOT_TIME} advertismeent!", "BLUE")
-        cert_common.wait_time_n_print(BRG_REBOOT_TIME - (int(datetime.datetime.now().timestamp()) - reboot_start_ts))
-    utPrint("Advertisement LED check completed!\n", "GREEN")
-
-    # ------------------  Energizing LED check  ------------------ #
-    #  Energizing is ON (Non default for SUB1G, but for UT purposses we'll set it to ON)
-    utPrint("Energizing LED check!", "HEADER")
-    utPrint(f"Is the Energizing LED ({ENERGIZING_LED_COLOR}) on? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test)
-
-    # Energizing is OFF
-    #  Default cfg for 2400 is 0 == no energizing so we only eliminating sub1g energizing
-    utPrint("Configuring the BRG to no energizing in sub1g", "WARNING")
-    sub1g_module = test.active_brg.energy_sub1g
-    test = cert_config.brg_configure(test, fields=[BRG_PATTERN], values=[ag.SUB1G_ENERGY_PATTERN_NO_ENERGIZING], module=sub1g_module)[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
-    utPrint(f"wait a few seconds for the change to apply - Is the Energizing LED ({ENERGIZING_LED_COLOR}) off? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
-    utPrint("Energizing LED check completed!\n", "GREEN")
-
-    # ------------------- Echo LED check -------------------------- #
-    utPrint("Echoing LED check!", "HEADER")
-    utPrint("Please make sure you have tags around you before answering!", "WARNING")
-    utPrint(f"Is the Echoing LED ({ECHOING_LED_COLOR}) blinking? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Echoing LED check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test)
-    utPrint("Echoing LED check completed!\n", "GREEN")
-
-    # ---------------- LEDS_KEEP_ALIVE_PERIOD_CHECK --------------- #
-    utPrint("LEDS_KEEP_ALIVE_PERIOD check!", "HEADER")
-    utPrint("Please remove all tags from the bridge surrounding for this check!", "WARNING")
-    utPrint(f"Look at the LEDS - Are both LED's off except for {LEDS_KEEP_ALIVE_BLINKS_NUM} blinks \n"
-            f"of the Echoing LED ({ECHOING_LED_COLOR}) every {LEDS_KEEP_ALIVE_PERIOD} seconds? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "LEDS_KEEP_ALIVE_PERIOD check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
-    utPrint("LEDS_KEEP_ALIVE_PERIOD check completed! - please restore the tags to position around the bridge\n", "GREEN")
-
-    # Revert to default
-    utPrint("Reverting the BRG to default configuration", "WARNING")
-    test = cert_config.config_brg_defaults(test, modules=[sub1g_module])[0]
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
-    utPrint(f"wait a few seconds for the change to apply - Is the Energizing LED ({ENERGIZING_LED_COLOR}) back on \n"
-            f" and the Echoing LED ({ECHOING_LED_COLOR}) blinking? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Eenergizing LED check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[sub1g_module])
-    utPrint("Succesfully Reverted the BRG to default configuration!\n", "GREEN")
-
-    # -----------------------  Blink check  ----------------------- #
-    value = 'n'
-    while True:
-        utPrint("Blink action check - pay attention to the LED's", "HEADER")
-        cert_config.send_brg_action(test, ag.ACTION_BLINK)
-        if board_type == ag.BOARD_TYPE_MINEW_POE_V0:
-            utPrint(f"wait a few seconds for the action to apply - "
-                    f"Did you see all 4 LED's blink {NUM_OF_LED_BLINKS_ACTION} times? (Y/N)", "BLUE")
-        else:
-            utPrint(f"wait a few seconds for the action to apply - "
-                    f"Did you see both LED's blink {NUM_OF_LED_BLINKS_ACTION} times? (Y/N)", "BLUE")
-        repeat = False
-        value = cert_common.check_input_n_try_again(input())
-        if value.lower() == 'n':
-            utPrint("Want to send the Blink action again?", "BLUE")
-            value = cert_common.check_input_n_try_again(input())
-            if value.lower() == 'y':
-                utPrint("Sending the Blink action again!", "WARNING")
-                repeat = True
-            elif value.lower() == 'n':
-                utPrint("No need to repeat - Let's proceed!", "GREEN")
-        if repeat is False:
-            break
-    test = cert_common.value_check_if_y(test, value, "Blink check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test)
-    utPrint("Blink action check completed!\n", "GREEN")
-
-    # ------------- Power management sleep & Keep Alive Mode ------------- #
-    utPrint("Power management Sleep state & Keep Alive Mode check!", "HEADER")
-    utPrint("Sending the BRG power management configuration in order to enter sleep state", "WARNING")
-    pwr_mgmt_module = test.active_brg.pwr_mgmt
-    test, wltpkt = cert_common.brg_pwr_mgmt_turn_on(test)
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        # Preventing leaving brg in pwr mgmt, protection for on that worked yet no ack was received
-        test = cert_common.brg_pwr_mgmt_turn_off(test)
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
-    utPrint("pwr mgmt static mode turned on!", "GREEN")
-    utPrint("Waiting for on_duration to expire!", "BLUE")
-    cert_common.wait_time_n_print(wltpkt.pkt.static_on_duration)
-    sleep_state_start_ts = int(datetime.datetime.now().timestamp())
-    utPrint("Now we'll check sleep_Keep_Alive state blink .\n", "WARNING")
-    utPrint(f"look ath the LEDS - Are all leds off, besides 1 blink ({wltpkt.pkt.static_keep_alive_scan} msec period) of the \n"
-            f"Echoing LED ({ECHOING_LED_COLOR}) every {wltpkt.pkt.static_keep_alive_period} seconds? (Y/N)", "BLUE")
-    value = cert_common.check_input_n_try_again(input())
-    test = cert_common.value_check_if_y(test, value, "Sleep Keep Alive mode check")
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
-    # wait for sleep_duration to expire to revert the bridge to defualt configuration
-    if wltpkt.pkt.static_sleep_duration - (int(datetime.datetime.now().timestamp()) - sleep_state_start_ts) > 0:
-        utPrint("Waiting for sleep_duration to expire", "BLUE")
-        cert_common.wait_time_n_print(wltpkt.pkt.static_sleep_duration - (int(datetime.datetime.now().timestamp()) - sleep_state_start_ts))
-    # Revert to default
-    test = cert_common.brg_pwr_mgmt_turn_off(test)
-    if test.rc == TEST_FAILED and test.exit_on_param_failure:
-        test = cert_common.brg_pwr_mgmt_turn_off(test)
-        return cert_common.test_epilog(test, revert_brgs=True, modules=[pwr_mgmt_module])
-    utPrint("Keep Alive Mode check completed!", "GREEN")
-
-    # ---------------------  Post stage ----------------------------- #
-    utPrint("Test is completed, Good job!!!", "GREEN")
-    return cert_common.test_epilog(test)

brg_certificate/tests/edge_mgmt/ota_test/ota_test.json

@@ -1,17 +0,0 @@
-{
-    "name": "Bridge OTA",
-    "module": "Edge Management",
-    "purpose": "Test Over-the-air (OTA) firmware update functionality",
-    "documentation": "<TEST_DOCUMENTATION_LINK>",
-    "initialCondition": "Bridge configured to defaults and connected to a GW",
-    "procedure": ["Test prolog",
-                  "Extract latest firmware version",
-                  "Perform BRG OTA firmware update",
-                  "Test epilog"],
-    "expectedOutcome": "BRG OTA firmware update was successful - bridge is running the latest firmware version",
-    "mandatory": 0,
-    "multiBridgeTest": 0,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": []
-}

brg_certificate/tests/edge_mgmt/ota_test/ota_test.py

@@ -1,128 +0,0 @@
-from brg_certificate.cert_prints import *
-from brg_certificate.cert_defines import *
-import brg_certificate.cert_common as cert_common
-import brg_certificate.cert_config as cert_config
-import brg_certificate.cert_utils as cert_utils
-import datetime
-import tabulate
-
-# Index 0 = stage name Index 1 = value log to find
-BRG_OTA_LOGS = {
-    "got ota action": "Got OTA action request for BRG",
-    "file download finish dat": "Downloaded files to /sd_images/ble_image_dat_file successfully",
-    "dat file open": "file opening /sd_images/ble_image_dat_file success",
-    "dat file transfer finish": "BRG_OTA_FILE_TRANSFER_FINISH",
-    "file download finish bin": "Downloaded files to /sd_images/ble_image_bin_file successfully",
-    "bin file open": "file opening /sd_images/ble_image_bin_file success",
-    "bin file transfer finish": "BRG_OTA_FILE_TRANSFER_FINISH",
-    "start brg ota": "Starting OTA to BRG",
-    "finish brg ota": "BRG OTA finished with status",
-}
-
-RECIEVED_REPORTS_TIMEOUT = 60
-
-EXPECTED_REPORTS = {
-    4: {0, 25, 50, 75, 100},
-    5: {0, 100},
-    6: {10, 20, 30, 40, 50, 60, 70, 80, 90, 100},
-    7: {100}
-}
-
-
-def get_report_status(test):
-    received = {step: set() for step in EXPECTED_REPORTS}
-    start_time = datetime.datetime.now()
-
-    while (datetime.datetime.now() - start_time).seconds < RECIEVED_REPORTS_TIMEOUT:
-        for p in test.mqttc._userdata["pkts"].status:
-            if ACTION_STATUS in p.body:
-                msg = p.body[ACTION_STATUS]
-                # Check that the packet contains the expected action, statusCode, and progress
-                if msg[ACTION] == ACTION_BRG_OTA:  # OTA action
-                    if STATUS_CODE_STR in msg and msg[STATUS_CODE_STR] != 0:
-                        test.rc = TEST_FAILED
-                        test.add_reason(f"Got the following error code during OTA : {p.body[STATUS_CODE_STR]}")
-                        return test
-                    else:
-                        step = msg[STEP]
-                        progress = msg[PROGRESS]
-                        # Only record progress if it is one of the expected values for this step
-                        if progress in EXPECTED_REPORTS[step]:
-                            received[step].add(progress)
-
-        # Check if every step has received all its expected progress values
-        if all(received[step] == EXPECTED_REPORTS[step] for step in EXPECTED_REPORTS):
-            utPrint("SUCCESS: Got all the required reports on the OTA process!", "GREEN")
-            return test
-
-        print_update_wait()
-
-    test.rc = TEST_FAILED
-    print("Not all reports on OTA were received")
-    test.add_reason("Not all reports on OTA were received")
-    return test
-
-
-def get_ts_from_log(log):
-    ts_end = log.find(']')
-    ts_str = log[1:ts_end]
-    # Convers from ms to sec
-    return int(ts_str) / 1000
-
-
-# Prints the time each step individually for regression & follow up purposes
-def breakdown_steps_timing(test, start_ts):
-    # timing data [step, is_found, time from start, stage timing]
-    timing_data = []
-    last_ts = start_ts
-
-    # Collect data
-    for step, log in BRG_OTA_LOGS.items():
-        found = []
-        suffix = "(dat)" if step.startswith("dat") else "(bin)" if step.startswith("bin") else ""
-        test, res, found = cert_common.single_log_search(test, log, found, fail_on_find=False, print_logs=False, additional_log=suffix)
-        time_from_start = -100  # invalid
-        step_time = -100  # invalid
-        if res:
-            found_ts = get_ts_from_log(found[0])
-            time_from_start = found_ts - start_ts
-            step_time = found_ts - last_ts
-            last_ts = found_ts
-        timing_data.append([step, res, round(time_from_start, 1), round(step_time, 1)])
-
-    # Create table
-    headers = ["Step", "Log Found", "Time From Start (secs)", "Step Time (secs)"]
-    print(tabulate.tabulate(tabular_data=timing_data, headers=headers, tablefmt="fancy_grid"))
-
-
-def run(test):
-
-    test = cert_common.test_prolog(test)
-    if test.rc == TEST_FAILED:
-        return cert_common.test_epilog(test, revert_brgs=True)
-
-    versions_mgmt2 = cert_utils.load_module('versions_mgmt2.py', f'{UTILS_BASE_REL_PATH}/versions_mgmt2.py')
-    reg_id = versions_mgmt2.get_board_type(env=AWS, server=TEST, board_name="wifi")[versions_mgmt2.BOARD_REG_ID]
-    if test.latest:
-        _, version = versions_mgmt2.get_versions(env=AWS, server=TEST, board_type_reg_id=reg_id, ci=True)
-    elif test.release_candidate:
-        _, version = versions_mgmt2.get_versions(env=AWS, server=TEST, board_type_reg_id=reg_id, rc=True)
-    else:
-        test.rc = TEST_FAILED
-        test.reason = NO_PARAMS_GIVEN
-        print(NO_PARAMS_GIVEN)
-
-    #  check for problems in prolog
-    if test.rc == TEST_FAILED or not version:
-        test = cert_common.test_epilog(test)
-        return test
-
-    start_time = datetime.datetime.now()
-    test = cert_config.brg_ota(test, gw_ble_version=version)
-    test = get_report_status(test)
-    generate_log_file(test, f"brg_ota_{version}")
-
-    if test.rc == TEST_PASSED and WANTED_VER_SAME not in test.reason:
-        breakdown_steps_timing(test, start_time.timestamp())
-
-    return cert_common.test_epilog(test)

brg_certificate/tests/energy2400/output_power_test/output_power_test.json

@@ -1,16 +0,0 @@
-{
-    "name": "Output Power",
-    "module": "Energizer 2.4GHz",
-    "purpose": "Test configuration for all supported Energizer 2.4GHz output power values",
-    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network-Energizing-2-4Ghz",
-    "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog",
-                  "For each supported value - configure the BRG and verify the value",
-                  "Test epilog and revert to defaults"],
-    "expectedOutcome": "All values configured successfully",
-    "mandatory": 0,
-    "multiBridgeTest": 0,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": [-12, -8, -4, 0, 2, 3]
-}

brg_certificate/tests/energy2400/signal_indicator_ble5_10_250k_test/signal_indicator_ble5_10_250k_test.json

@@ -1,20 +0,0 @@
-{
-    "name": "Signal Indicator BLE5 E2/E3 Pixels",
-    "module": "Energizer 2.4GHz",
-    "purpose": "verify Energizer 2.4GHz signal indicator functionality for BLE_5.0 in CHANNEL_10 for E2/E3 pixels modulation",
-    "documentation": "https://community.wiliot.com/customers/s/article/Bridge-to-Bridge-Signal-Indicator",
-    "initialCondition": "Bridge configured to defaults",
-    "procedure": ["Test prolog",
-    "rssi_threshold - check the if rssi value is between 0 to -25.",
-    "brg0_tx_brg1_rx - one brg is transmitter and the second is receiver, we expect to get the same values from the receiver, according to the tx params",
-    "brg0_none_brg1_rx - One rx BRG without any tx BRG. We don't expect to see any signal indicator packets.",
-    "brg0_rxtx_brg1_rxtx - Both BRG's will be configured to be transmitters and receivers, with different tx params for each one. we expect to see signal indicator packets from both BRG's, according to the tx params.",
-    "brg0_tx_brg1_none - One BRG will be configured as signal indicator tx, but no rx, so we don't expect to receive signal indicator packets.",
-    "Test epilog"],
-    "expectedOutcome": "All phases passed successfully!",
-    "mandatory": 0,
-    "multiBridgeTest": 1,
-    "gwOnlyTest": 0,
-    "internalBridge": 1,
-    "allSupportedValues": ["rssi_threshold", "brg0_tx_brg1_rx", "brg0_none_brg1_rx", "brg0_rxtx_brg1_rxtx", "brg0_tx_brg1_none"]
-}