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

certificate/tests/cloud_connectivity/registration_test/registration_test.py

@@ -0,0 +1,384 @@
+
+import datetime
+import time
+import os
+import requests
+import json
+
+from enum import Enum
+from typing import Literal
+
+from certificate.cert_defines import TEST_FAILED, TEST_PASSED, TEST_SKIPPED
+from certificate.cert_prints import phase_run_print
+
+import certificate.cert_utils as cert_utils
+import certificate.cert_common as cert_common
+
+
+# HELPER DEFINES
+GW_REGISTER_DOC = "https://community.wiliot.com/customers/s/article/Registering-Third-Party-Gateways"
+GW_MQTT_DOC = "https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud"
+
+REGISTRATION_API_KEY_ENV_VAR = "REGISTRATION_TEST_API_KEY"
+
+REG_CERT_OWNER_ID = 'gw-certification-account'
+
+STAGES_TIMEOUT_MINUTES = 2
+TOKEN_EXPIRY_MINUTES = 3
+CLOUD_DELAY_SEC = 7
+BUSY_WAIT_DELAY_SEC = 5
+STAGE_START_DELAY_MS = (BUSY_WAIT_DELAY_SEC + CLOUD_DELAY_SEC + 1) * 1000
+
+ERROR_NO_REGISTER = 'Gateway did not register itself in time.'
+ERROR_NO_ONLINE = 'Gateway did not connect to MQTT in time.'
+ERROR_NO_ACTIVE = 'Gateway did not upload a status message with its configurations in time.'
+ERROR_NO_REFRESH = 'Gateway did not reconnect to MQTT in time.'
+
+HEADERS = {
+    "accept": "application/json",
+    "Content-Type": "application/json",
+    "Authorization": None
+}
+BASE_URL = "https://api.us-east-2.prod.wiliot.cloud"
+OWNER_URL = BASE_URL + f"/v1/owner/{REG_CERT_OWNER_ID}"
+API_TOKEN_URL = BASE_URL + '/v1/auth/token/api'
+
+# GLOBALS
+api_key = None
+gw_online_ts = None
+
+
+# HTTP RELATED
+class HttpMethod(str, Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    DELETE = "DELETE"
+
+
+def http_request(path, payload, request_method: HttpMethod):
+    headers = HEADERS
+
+    def get_token():
+        headers = {
+            'Authorization': api_key
+        }
+        response = requests.post(API_TOKEN_URL, headers=headers)
+        if response.status_code == 200:
+            token = response.json()
+            return token["access_token"]
+        else:
+            raise Exception(f"Failed to get token. statuscode: {response.status_code}, {response.text}")
+
+    headers['Authorization'] = get_token()
+    response = requests.request(request_method, (OWNER_URL + path), headers=headers, data=payload)
+    try:
+        message = response.json()
+    except json.JSONDecodeError:
+        message = response.text
+    if isinstance(message, str):
+        message = {"data": message}
+    message.update({'status_code': response.status_code})
+    return message
+
+
+def get_gateway(gateway_id):
+    path = f"/gateway/{gateway_id}"
+    result = http_request(path, payload=None, request_method=HttpMethod.GET)
+    if result['status_code'] != 200:
+        raise Exception(f"get_gateway request failed with status_code {result['status_code']}")
+    return result["data"]
+
+
+def register_gateway(gateways: list):
+    payload = {
+        "gateways": gateways
+    }
+    path = "/gateway"
+    response = http_request(path, payload=json.dumps(payload), request_method=HttpMethod.PUT)
+    return (response.get("data", "").lower() == "ok", response)
+
+
+def delete_gateway(gateway_id):
+    path = f"/gateway/{gateway_id}"
+    response = http_request(path, payload=None, request_method=HttpMethod.DELETE)
+    return response.get('message', "").lower().find("success") != -1
+
+
+def kick_gw_from_mqtt(gw_id):
+    path = f"/gateway/{gw_id}/kick-mqtt-connection"
+    response = http_request(path, payload=None, request_method=HttpMethod.POST)
+    return response
+
+
+def get_kong_logs(gw_id):
+    """
+    Only available under the certificate registration account
+    """
+    path = f"/gateway/{gw_id}/auth-logs"
+
+    return http_request(path, payload=None, request_method=HttpMethod.GET)
+
+
+# TEST RELATED
+class GetGwField(Enum):
+    STATUS = 'status'
+    ONLINE = 'online'
+    ONLINE_UPDATED_AT = 'onlineUpdatedAt'
+    ACTIVATED_AT = 'activatedAt'
+
+
+class Status(Enum):
+    PRE_REGISTERED = 'pre-registered'
+    REGISTERED = 'registered'
+    APPROVED = 'approved'
+    ACTIVE = 'active'
+
+
+class GenericRegistrationStage():
+    def __init__(self, dut, **kwargs):
+        self.__dict__.update(kwargs)
+        self.dut = dut
+        self.start_time = None
+        self.duration = datetime.timedelta(0)
+        self.report = ''
+        self.error_summary = ''
+
+    def calc_run_duration(self):
+        self.duration = datetime.datetime.now() - self.start_time
+
+    def add_report_header(self):
+        self.report += f'This phase {(self.stage_tooltip.lower())}.\n'
+        self.report += '-' * 50 + '\n'
+
+    def get_gateway_field(self, field: GetGwField):
+        temp = get_gateway(self.dut)
+        return temp[field.value]
+
+    def kick_gw_from_mqtt(self):
+        response = kick_gw_from_mqtt(self.dut)
+        print(f"Kick response:{response}")
+
+    def validate_kong_logs(self, endpoint: Literal['device-authorize', 'registry', 'token', 'refresh']):
+        message = get_kong_logs(self.dut)
+        status_code = message.get('status_code')
+        if status_code == 404:
+            response_data = message.get('message')
+            if 'not found' in response_data:
+                print("Could not find gw when requesting for logs.")
+                print("Either it is not registered, didn't issue any requests, or is missing the X-Gateway-ID header.")
+                return False
+            else:
+                raise Exception(f'Failed getting kong logs: {response_data}')
+        if isinstance(message, dict) and message.get('status_code') != 200:
+            print(f"Failed fetching logs, status_code:{message.get('status_code')}")
+            return False
+
+        # Convert datetime.datetime.now() format to epoch in MS
+        stage_start_ts = self.start_time.timestamp() * 1000 - STAGE_START_DELAY_MS
+
+        for log in message['data']:
+            if log['timestamp'] > stage_start_ts and endpoint in log['endpoint']:
+                response_code = log['responseCode']
+                if response_code != 200:
+                    print(f"An HTTP request to /{endpoint} resulted in an invalid response code:{response_code}")
+                else:
+                    print(f"A valid HTTP request to /{endpoint} was received")
+                    return True
+
+        print(f"No valid HTTP request to /{endpoint} was found")
+        return False
+
+    def prepare_stage(self):
+        pass
+
+
+class Registry(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway's registry step"
+        super().__init__(name=type(self).__name__, **self.__dict__)
+
+    def prepare_stage(self):
+        print('Pre-registering the gateway, please make sure it is not registered to any other account '
+              'and that your device is ready to run the registration flow')
+
+        def pre_register_gw_anew(gw_id):
+            pre_registered, message = register_gateway([gw_id])
+            status_code = message.get('status_code')
+            if status_code == 400:
+                response_data = message.get('message')
+                if 'already exists' in response_data:
+                    print(f'{gw_id} already exists in Wiliot platform! Deleting and pre-registering from scratch')
+                    self.kick_gw_from_mqtt()
+                    delete_gateway(gw_id)
+                    time.sleep(CLOUD_DELAY_SEC)
+                    pre_registered, message = register_gateway([gw_id])
+            if status_code == 403:
+                raise Exception(f"The API key within {REGISTRATION_API_KEY_ENV_VAR} seems invalid."
+                                " It is not authorized to pre-register the gateway")
+            return pre_registered, message
+
+        pre_registered, message = pre_register_gw_anew(self.dut)
+        if not pre_registered:
+            print(f'Failed pre-registering the gateway. HTTP response:\n{message}')
+            raise Exception("Failed pre-registering the gateway. Make sure: Your API key is valid,"
+                            " and you have a stable internet connection. Otherwise, try again later.")
+        print(f"{self.dut} was pre-registered successfully")
+
+    def run(self):
+        self.start_time = datetime.datetime.now()
+        print("Waiting for the gateway to finish the Registry step..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT_MINUTES)
+        self.status = self.get_gateway_field(GetGwField.STATUS)
+        while datetime.datetime.now() < timeout and not any(self.status == s.value for s in {Status.APPROVED, Status.ACTIVE}):
+            time.sleep(BUSY_WAIT_DELAY_SEC)
+            self.status = self.get_gateway_field(GetGwField.STATUS)
+
+        time.sleep(CLOUD_DELAY_SEC)
+        self.validate_kong_logs('device-authorize')
+        self.validate_kong_logs('registry')
+        self.calc_run_duration()
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if not any(self.status == s.value for s in {Status.APPROVED, Status.ACTIVE}):
+            self.error_summary = ERROR_NO_REGISTER
+            self.report += f'{ERROR_NO_REGISTER}\n'
+            print(f"The gateway failed to register. Its status is '{self.status}' while it is expected to be '{Status.APPROVED.value}'.")
+            self.report += "There was an error in the Device-authorize or Registry steps.\n"
+            self.report += f"Please go over the Device-authorize and Registry sections in this document:\n{GW_REGISTER_DOC}\n"
+            if self.status == Status.REGISTERED:
+                self.report += "Highly likely that the gateway is missing the 'X-Gateway-ID' header in it's HTTP requests.\n"
+            return False
+        else:
+            self.report += "Device-authorize and Registry requests were issued well.\n"
+            self.report += "Gateway registered successfully.\n"
+            print("Gateway registered successfully")
+            return True
+
+
+class Online(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway become online on the platform"
+        super().__init__(name=type(self).__name__, **self.__dict__)
+
+    def run(self):
+        self.start_time = datetime.datetime.now()
+        print("Waiting for the gateway to connect to MQTT..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT_MINUTES)
+        self.online = self.get_gateway_field(GetGwField.ONLINE)
+        while datetime.datetime.now() < timeout and self.online is not True:
+            time.sleep(BUSY_WAIT_DELAY_SEC)
+            self.online = self.get_gateway_field(GetGwField.ONLINE)
+
+        time.sleep(CLOUD_DELAY_SEC)
+        self.validate_kong_logs('token')
+        if self.online:
+            global gw_online_ts
+            gw_online_ts = datetime.datetime.now()
+        self.calc_run_duration()
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if self.online is not True:
+            self.error_summary = ERROR_NO_ONLINE
+            self.report += f'{ERROR_NO_ONLINE}\n'
+            self.report += "Either it didn't acquire a token or it didn't connect to MQTT in time.\n"
+            self.report += f"Please go over the Poll For Token section in:\n{GW_REGISTER_DOC}\n"
+            self.report += f"and the MQTT details in:\n{GW_MQTT_DOC}\n"
+            print("Gateway did not connect to MQTT within time limit")
+            return False
+        else:
+            self.report += "Token acquisition and MQTT connection were done succesfully.\n"
+            self.report += "Gateway is online.\n"
+            print("Gateway connected to MQTT successfully, it is online")
+            return True
+
+
+class Refresh(GenericRegistrationStage):
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+        self.stage_tooltip = "Validate the gateway refresh-token step"
+        super().__init__(name=type(self).__name__, **self.__dict__)
+
+    def run(self):
+        self.start_time = datetime.datetime.now()
+        print("Waiting for the token to expire..")
+        timeout = gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
+        while datetime.datetime.now() < timeout:
+            time.sleep(BUSY_WAIT_DELAY_SEC)
+
+        print("Token expired, kicking gateway")
+        self.kick_gw_from_mqtt()
+
+        # Sleep here since it sometimes take time for the cloud to kick and change the gateway's online status
+        time.sleep(CLOUD_DELAY_SEC)
+        print("Waiting for the gateway to refresh its token and connect to MQTT..")
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT_MINUTES)
+        self.online = self.get_gateway_field(GetGwField.ONLINE)
+        while datetime.datetime.now() < timeout and self.online is not True:
+            time.sleep(BUSY_WAIT_DELAY_SEC)
+            self.online = self.get_gateway_field(GetGwField.ONLINE)
+
+        time.sleep(CLOUD_DELAY_SEC)
+        self.validate_kong_logs('refresh')
+        self.calc_run_duration()
+
+    def generate_stage_report(self):
+        self.add_report_header()
+        if self.online is not True:
+            self.error_summary = ERROR_NO_REFRESH
+            self.report += f'{ERROR_NO_REFRESH}\n'
+            self.report += "Either it didn't refresh its token or it didn't connect to MQTT in time.\n"
+            self.report += f"Please go over the Refresh Token section in:\n{GW_REGISTER_DOC}\n"
+            self.report += f"and the MQTT details in:\n{GW_MQTT_DOC}\n"
+            print("Gateway did not reconnect MQTT (was the token refreshed?)")
+            return False
+        else:
+            self.report += "Token refresh and MQTT reconnection were done succesfully.\n"
+            self.report += "Gateway is online.\n"
+            return True
+
+
+def end_test(dut):
+    print(f'Deleting {dut} from {REG_CERT_OWNER_ID} before exiting')
+    time.sleep(CLOUD_DELAY_SEC)
+    delete_gateway(dut)
+
+
+def prepare_results(stage, phase_pass, skip_stage):
+    stage.rc = TEST_SKIPPED if skip_stage else TEST_PASSED if phase_pass else TEST_FAILED
+
+
+def run(test: cert_utils.WltTest):
+    test = cert_common.test_prolog(test, flush_mqtt=False)
+    if test.rc == TEST_FAILED:
+        return cert_common.test_epilog(test, flush_mqtt=False)
+
+    global api_key
+    api_key = os.getenv(REGISTRATION_API_KEY_ENV_VAR)
+    if api_key is None:
+        raise Exception('Must include an apikey')
+
+    STAGES = [Registry, Online, Refresh]
+    phases = {p.name: stage(dut=test.dut.id_str) for p, stage in zip(test.params, STAGES)}
+
+    for param in test.params:
+        phase_run_print(f" - {param.name}")
+        phase = phases[param.name]
+        phase.prepare_stage()
+        phase.run()
+        test.rc = TEST_PASSED if phase.generate_stage_report() else TEST_FAILED
+        test.set_phase_rc(param.name, test.rc)
+        test.add_phase_reason(param.name, phase.error_summary)
+
+        if test.rc == TEST_FAILED and test.exit_on_param_failure:
+            print(f'\nPhase {param.name} failed: {phase.report}')
+            break
+        test.reset_result()  # reset result and continue to next param
+
+    end_test(test.dut.id_str)
+
+    return cert_common.test_epilog(test, flush_mqtt=False)

certificate/tests/cloud_connectivity/registration_test/registration_test_cli.py

@@ -0,0 +1,90 @@
+
+import datetime
+from argparse import ArgumentParser
+import os
+import traceback
+import webbrowser
+import tabulate
+
+from certificate.cert_defines import CERT_VERSION, TEST_FAILED, TEST_PASSED, TEST_SKIPPED
+from certificate.cert_prints import *
+import certificate.cert_common as cert_common
+import certificate.cert_utils as cert_utils
+import certificate.cert_results as cert_results
+
+import certificate.tests.cloud_connectivity.registration_test.registration_test as registration_test
+
+
+# HELPER DEFINES
+TEST_LINE = "cloud_connectivity/registration_test registry online refresh"
+
+
+class RegTestCli:
+    """Registration Test CLI."""
+    def __init__(self):
+        usage = ("wlt-reg-test [-h] -dut <GWID> -ak <API_KEY>\n")
+
+        self.parser = ArgumentParser(prog='wlt-reg-test',
+                                     description=f'Registration Test v{CERT_VERSION}', usage=usage)
+
+        self.required = self.parser.add_argument_group('required arguments')
+        self.required.add_argument('--dut', type=str, help="Gateway ID", required=True)
+        self.required.add_argument('--apikey', '-ak', type=str, help="API key provided by Wiliot", required=True)
+
+    def parse_args(self, args=None):
+        """Parse arguments and return them."""
+        return self.parser.parse_args(args)
+
+
+def prepare_results(stage, phase_pass, skip_stage):
+    stage.rc = TEST_SKIPPED if skip_stage else TEST_PASSED if phase_pass else TEST_FAILED
+
+
+def main():
+    cli = RegTestCli()
+    args = cli.parse_args()
+
+    os.environ[registration_test.REGISTRATION_API_KEY_ENV_VAR] = f"{args.apikey}"
+
+    start_time = datetime.datetime.now()
+    dut = cert_utils.Gateway(id_str=args.dut)
+
+    test = cert_utils.WltTest(TEST_LINE, '', dut, exit_on_param_failure=True)
+    tests = [test]
+
+    # Running the tests
+    utPrint(SEP)
+    utPrint("\n - ".join([f"\nRunning {len(tests)} tests:"] +
+                         [t.name if not t.internal_brg else f"{t.name} (internal brg)" for t in tests]))
+
+    failures, skipped = 0, 0
+    i = 0
+
+    try:
+        test_module_name = cert_utils.load_module(f'{test.module_name}.py', f'{test.dir}/{test.module_name}.py')
+        test = test_module_name.run(test)
+    except Exception as e:
+        traceback.print_exc()
+        test.add_phase_reason(RESTORE_CONFIG, f"Exception occurred: {e!r}")
+        test.rc = TEST_FAILED
+    finally:
+        test.update_overall_rc()
+    if test.rc == TEST_FAILED:
+        failures += 1
+    print(f"Test Duration: {test.duration}")
+    print(tabulate.tabulate([[i + 1, i + 1 - (failures + skipped), skipped, failures, len(tests)]],
+                            headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
+    cert_common.wait_time_n_print(2)
+
+    # Print results
+    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)))
+
+    if failures:
+        sys.exit(-1)
+
+
+if __name__ == '__main__':
+    main()

certificate/tests/cloud_connectivity/stress_test/stress_test.json

@@ -0,0 +1,17 @@
+{
+    "name": "Gateway Uplink Stress",
+    "module": "Cloud Connectivity",
+    "purpose": "Test gateway's stress handling capabilities for different rates and durations",
+    "documentation": "https://community.wiliot.com/customers/s/article/Sending-Wiliot-Packets-to-the-Wiliot-Cloud",
+    "initialCondition": "Gateway configured to defaults, in a BLE-clean environment",
+    "procedure": ["Test prolog",
+                  "For each pps value, advertise packets at that rate, once on each of the three BLE advertising channels, and compare the advertised vs uploaded rate",
+                  "Test epilog"],
+    "expectedOutcome": "Find the maximum PPS supported by the gateway",
+    "mandatory": 1,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 203,
+    "allSupportedValues": []
+}

certificate/tests/cloud_connectivity/stress_test/stress_test.py

@@ -0,0 +1,101 @@
+
+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_utils as cert_utils
+import certificate.cert_mqtt as cert_mqtt
+import certificate.cert_config as cert_config
+import certificate.cert_gw_sim as cert_gw_sim
+import math
+
+
+# DEFINES
+STRESS_TEST_INDICATOR = get_random_hex_str(6)
+
+DUPLICATES = 1
+ADVA_ASCII_LEN = 12
+
+LOWEST_PPS = 20
+ADV_DURATION_LOWEST_PPS = 50
+ADV_DURATION_DEFAULT = 30
+
+
+# HELPER FUNCTIONS
+
+
+def generate_adv_payloads_list(payload, duplicates):
+    """
+    Should always stay synced to how cmd_ble_sim generate additional packets with unique_pkts_count
+    """
+    payload_start = payload[:-8]
+    last_hex = payload[-8:]
+    last_int = int.from_bytes(bytes.fromhex(last_hex), byteorder='little', signed=False)
+
+    pkts_list = []
+    for i in range(duplicates):
+        value = last_int + i
+        # Convert back to 4 bytes in little-endian and then to hex
+        new_hex = value.to_bytes(4, byteorder='little', signed=False).hex().upper()
+
+        pkts_list.append(payload_start + new_hex)
+
+    return pkts_list
+
+
+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)
+    ppses = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 222, 250, 285, 333, 500]
+    test_pkts_received = []
+    data_pkts_received = []
+    results = []
+    for pps in ppses:
+        phase_run_print(f"PPS = {pps}")
+        test.flush_all_mqtt_packets()
+        # adv_duration is increased only for lowest pps to increase packets sample for reliable results
+        adv_duration = ADV_DURATION_LOWEST_PPS if pps == LOWEST_PPS else ADV_DURATION_DEFAULT
+        delay = math.floor(1000 / pps)
+        upload_wait_time = test.dut.upload_wait_time + 15
+
+        # Generate pkts and get ready to advertise
+        payload = cert_common.generate_adv_payload(STRESS_TEST_INDICATOR)
+        generated_payloads = generate_adv_payloads_list(payload, adv_duration * pps)
+
+        # We provide the tester with the first pkt only. It then advertises in a loop pkts identical
+        # to the ones we generated (by incrementing the last bytes).
+        cert_config.gw_action(test, f'{cert_gw_sim.BLE_SIM} {generated_payloads[0]} {DUPLICATES} {OUTPUT_POWER_2_4_MAX} '
+                              f'{BLE_SIM_ADV_37_38_39} {delay} {BLE_SIM_RADIO_1MBPS} {adv_duration * pps}', TESTER)
+        mqtt_scan_wait(test, adv_duration + upload_wait_time)
+
+        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
+        phase_pkts_received = [p[PAYLOAD] for p in phase_pkts_received]
+        test, received_pps = cert_common.stress_analysis(test, pps, generated_payloads, phase_pkts_received)
+        results.extend([pps, received_pps])
+        cert_mqtt.generate_log_file(test, str(pps))
+
+        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
+        data_pkts_received.extend(cert_mqtt.get_all_data_pkts(test.get_mqttc_by_target(DUT)))
+        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)
+
+    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.json

@@ -0,0 +1,25 @@
+{
+    "name": "Gateway Uplink Extended Advertising",
+    "module": "Cloud Connectivity",
+    "purpose": "Verify gateway BLE scans and MQTT uplinks in Extended Advertising mode",
+    "documentation": "https://community.wiliot.com/customers/s/article/Wiliot-Network---Gateway-Extended-Advertising-Implementation",
+    "initialCondition": "Gateway configured to defaults",
+    "procedure": [
+        "Test prolog",
+        "Enable GW CERT TESTER to allow TESTER transmit extended advertising packets",
+        "Configure TESTER datapath pattern to Extended Advertising (DATAPATH_PATTERN_EXTENDED_ADV)",
+        "Flush MQTT packets; generate pixel packets with 31-byte payload and send via GenericSimThread (single cycle)",
+        "Wait for MQTT scan (≈20s)",
+        "Analyze: each 31-byte payload must be expanded to aggregated 217 bytes (31×7) and repeated 7 times; validate ≥80% of expected payloads received",
+        "Restore TESTER datapath defaults and disable GW CERT TESTER",
+        "Generate log and pass/fail summary",
+        "Test epilog"
+    ],
+    "expectedOutcome": "Received amount of aggregated packets matches the expected amount and all additional validations pass as expected",
+    "mandatory": 0,
+    "multiBridgeTest": 0,
+    "gwOnlyTest": 1,
+    "dataSimOnlyTest": 1,
+    "SupportedFromApiVersion": 206,
+    "allSupportedValues": []
+}