wiliot-certificate 1.4.0a2__py3-none-any.whl → 1.5.1a1__py3-none-any.whl

brg_certificate/brg_certificate.py

@@ -3,7 +3,7 @@
 import sys
 import os
 sys.path.insert(0, os.path.abspath(".."))
-import argparse
+import webbrowser
 import glob
 import datetime
 import tabulate
@@ -38,6 +38,8 @@ def skip_test_check(test, args):
     skip_string = ""
     if test.multi_brg and not test.brg1:
         skip_string = f"Skipped {test.module_name} multi brg test because brg1 wasn't given"
+    elif (args.brg_cloud_connectivity or test.internal_brg) and not test.test_json[INTERNAL_BRG]:
+        skip_string = f"Skipped {test.module_name} because test is unable to run on an internal brg"
     elif args.skip_internal and test.internal_brg:
         skip_string = f"Skipped {test.module_name} for internal brg because skip_internal flag is set"
     elif test.active_brg and not test.active_brg.is_sup_cap(test):
@@ -86,7 +88,16 @@ def main(args):
             sys.exit(0)
 
     # Init mqtt client
-    mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+    if args.brg_cloud_connectivity:
+        # Mqtt client for tested device
+        mqttc = cert_mqtt.mqttc_init(args.brg_cloud_connectivity, data=args.data)
+        # Mqtt client for testing device
+        sim_mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+    else:
+        # Single mqtt client for a single device with cloud connectivity
+        mqttc = cert_mqtt.mqttc_init(args.gw, data=args.data)
+        sim_mqttc = mqttc
+
 
     # Run Gateway Simulator in separated thread if exists
     gw_sim_thread = None
@@ -105,12 +116,29 @@ def main(args):
 
     # Prepare GW
     if gw_sim_thread:
-        gw, internal_brg, gw_server, gw_version, protobuf = cert_gw_sim.prep_gw(args, mqttc, start_time)
+        if args.brg_cloud_connectivity:
+            # Prepare tested device
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+            # Prepare testing device
+            _, internal_brg_sim, _, _, _ = cert_gw_sim.prep_gw(args, sim_mqttc, start_time)
+        else:
+            # Prepare single device with cloud connectivity
+            gw, internal_brg, gw_server, gw_version, protobuf = cert_gw_sim.prep_gw(args, mqttc, start_time)
     else:
-        gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+        if args.brg_cloud_connectivity:
+            # Prepare tested device
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
+            # Prepare testing device
+            _, internal_brg_sim, _, _, _ = ut_prep_gw(args, sim_mqttc, start_time, tester_gw=True)
+        else:
+            # Prepare single device with cloud connectivity
+            gw, internal_brg, gw_server, gw_version, protobuf = ut_prep_gw(args, mqttc, start_time)
 
     brg0, brg1 = None, None
-    if args.brg:
+    if args.brg_cloud_connectivity:
+        brg0 = internal_brg
+        internal_brg = internal_brg_sim
+    elif args.brg:
         brg0 = ut_prep_brg(args, mqttc, start_time, gw, args.brg, gw_server, protobuf)
         if args.brg1:
             brg1 = ut_prep_brg(args, mqttc, start_time, gw, args.brg1, gw_server, protobuf)
@@ -119,7 +147,7 @@ def main(args):
     tests = []
     for l in open(os.path.join(BASE_DIR, test_list)).readlines():
         if l.strip() and not l.strip().startswith("#"):
-            test = (WltTest(l.strip(), gw, mqttc, exit_on_param_failure=args.exit_on_param_failure, gw_lan=args.lan,
+            test = (WltTest(l.strip(), gw, mqttc, sim_mqttc=sim_mqttc, exit_on_param_failure=args.exit_on_param_failure, gw_lan=args.lan,
                     gw_orig_versions={BLE_VERSION:gw_version[BLE_VERSION], WIFI_VERSION:gw_version[WIFI_VERSION]},
                     server=gw_server, latest=args.latest, release_candidate=args.rc, private_setup=args.private_setup, internal_brg_obj=internal_brg,
                     gw_sim=gw_sim_thread, data=args.data, port=args.port, protobuf=protobuf))
@@ -150,13 +178,15 @@ def main(args):
         test_module_name = load_module(f'{test.module_name}.py', f'{test.dir}/{test.module_name}.py')
         test = skip_test_check(test, args)
         if test.rc == TEST_SKIPPED:
+            for phase in test.phases:
+                phase.rc = TEST_SKIPPED
             skipped += 1
         else:
             test = test_module_name.run(test)
             test.update_overall_rc()
         if test.rc == TEST_FAILED:
             failures += 1
-            if "versions_test" in test.module_name and "EXITING UT" in test.reason:
+            if "versions_test" in test.module_name and f"EXITING CERTIFICATE" in test.reason:
                 exit_on_test_failure = True
         print(f"Test Duration: {test.duration}")
         print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
@@ -177,12 +207,16 @@ def main(args):
     print(tabulate.tabulate([[i+1, i+1-(failures+skipped), skipped, failures, len(tests)]],
                             headers=["FINISHED", "PASSED", "SKIPPED", "FAILED", "TOTAL"], tablefmt="pretty"))
 
-    print(WIL_UT_TEXT)
+    print(WIL_CERT_TEXT)
     print_warn(get_important_tests_info())
-    print_pass_or_fail(not failures, "Wiliot UT")
-
-    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, duration=duration, brg_version=brg_version,
-                                  tests=tests, pipeline=cert_common.pipeline_running())
+    print_pass_or_fail(not failures, f"Wiliot Certificate")
+
+    pipeline = cert_common.pipeline_running()
+    # brg = args.brg_cloud_connectivity if args.brg_cloud_connectivity else args.brg
+    cert_results.generate_results_files(html=True, pdf=True, failures=failures, skipped=skipped, start_time=start_time, duration=duration,
+                                        brg=test.active_brg, internal_brg=internal_brg, tests=tests, pipeline=pipeline)
+    if not pipeline:
+        webbrowser.open('file://' + os.path.realpath(os.path.join(BASE_DIR, UT_RESULT_FILE_PDF)))
 
     if failures:
         sys.exit(-1)

brg_certificate/brg_certificate_cli.py

@@ -13,6 +13,7 @@ class BrgCertificateCLI:
             description="Bridge Certificate CLI",
         )
         self.parser.add_argument('--brg', '-b', default="", help='Bridge id to run on the tests')
+        self.parser.add_argument('--brg_cloud_connectivity', '-bcc', default="", help='Bridge with cloud connectivity id to run on the tests')
         self.parser.add_argument('--brg1', '-b1', default="", help='Second bridge id to run on tests two bridges needed')
         self.parser.add_argument('--gw', '-g', type=str, required=True, help='GW id to run on the test, SIM prefix is used for Gateway simulation')
         self.parser.add_argument('--data', '-d', choices=[DATA_REAL_TAGS, DATA_SIMULATION], default=DATA_REAL_TAGS, help='Choose if data generated from real tags or by simulation')

brg_certificate/cert_common.py

@@ -13,7 +13,7 @@ import math, random
 DEFAULT_HDR = ag.Hdr(group_id=ag.GROUP_ID_GW2BRG)
 
 # Returns a 12 chars long hex string
-int2mac_get = lambda int_val: "{:012X}".format(int_val)
+int2mac_get = lambda int_val: f"{int_val:012X}"
 
 def name_to_val(name):
     return globals()[name]
@@ -35,8 +35,8 @@ def test_prolog(test):
     test.mqttc.flush_pkts()
 
     #TODO - remove/check status later on in the test
-    test.set_phase_rc(PROLOG, rc=test.rc) 
-    test.add_phase_reason(PROLOG, reason=test.reason)
+    test.set_phase_rc(PRE_CONFIG, rc=test.rc) 
+    test.add_phase_reason(PRE_CONFIG, reason=test.reason)
     #
 
     return test
@@ -59,37 +59,37 @@ def test_epilog(test, revert_brgs=False, revert_gws=False, modules=[], brg1_modu
         test.add_phase_reason(TEST_BODY, test.reason)
 
     test.reset_result()
-    test.set_phase_rc(EPILOG, TEST_PASSED)
+    test.set_phase_rc(RESTORE_CONFIG, TEST_PASSED)
 
     if revert_brgs:
         res2 = DONE
         test, res = cert_config.config_brg_defaults(test, modules=modules, ble5=ble5)
         # TODO - REMOVE when rc is re-designed
-        test.set_phase_rc(EPILOG, test.rc)
+        test.set_phase_rc(RESTORE_CONFIG, test.rc)
         test.reset_result()
         #
         if test.brg1 and test.multi_brg:
             brg1_modules = modules if not brg1_modules else brg1_modules
             test, res2 = cert_config.config_brg1_defaults(test, modules=brg1_modules)
             # TODO - REMOVE when rc is re-designed
-            test.set_phase_rc(EPILOG, test.rc)
+            test.set_phase_rc(RESTORE_CONFIG, test.rc)
             test.reset_result()
             #
         if res == NO_RESPONSE or res2 == NO_RESPONSE:
             txt = "Failed: Revert BRGs to defaults"
             utPrint(txt, "RED")
-            test.add_phase_reason(EPILOG, txt)
+            test.add_phase_reason(RESTORE_CONFIG, txt)
 
     if revert_gws:
         test, res = cert_config.config_gw_defaults(test)
         # TODO - REMOVE when rc is re-designed
-        test.set_phase_rc(EPILOG, test.rc)
+        test.set_phase_rc(RESTORE_CONFIG, test.rc)
         test.reset_result()
         #
         if res == NO_RESPONSE:
             txt = "Failed: Revert GW to defaults"
             utPrint(txt, "RED")
-            test.add_phase_reason(EPILOG, txt)
+            test.add_phase_reason(RESTORE_CONFIG, txt)
 
     test.mqttc.flush_pkts()
     test.end_time = datetime.datetime.now()
@@ -101,7 +101,7 @@ def test_epilog(test, revert_brgs=False, revert_gws=False, modules=[], brg1_modu
         and test.get_phase_rc(TEST_BODY) == TEST_FAILED):
         print("Setting rc to TEST_PASSED for pipeline after BRG OTA succeeded")
         test.set_phase_rc(TEST_BODY, TEST_PASSED)
-        test.set_phase_rc(EPILOG, TEST_PASSED)
+        test.set_phase_rc(RESTORE_CONFIG, TEST_PASSED)
 
     test_epilog_print(test)
     return test
@@ -259,7 +259,11 @@ time_in_sec = lambda t : t.seconds + t.microseconds / 1000000
 
 def get_all_brg_pkts(test):
     utPrint(f"Collecting all BRG pkts", "BLUE")
-    return cert_mqtt.get_unified_data_pkts(test)
+    return cert_mqtt.get_unified_data_pkts(test, only_active_brg=True)
+
+def get_all_brgs_pkts(test):
+    utPrint(f"Collecting all BRG pkts", "BLUE")
+    return cert_mqtt.get_unified_data_pkts(test, only_active_brg=False)
 
 def get_pkts_data_frame(test, gw_data=False, brg_data=False, per_pkt_type=False):
     pkts = []
@@ -435,7 +439,7 @@ def pacing_analysis(test, pacer_interval, df, pkt_filter_cfg=ag.PKT_FILTER_RANDO
         if test.data == DATA_SIMULATION and (avg_pacer / pacer_interval) > PACER_INTERVAL_CEIL_THRESHOLD:
             failed_tags += 1
             print(f"Tag {tag} with diff_time {list(pkts.timestamp.diff().div(1000))}, avg_pacer={avg_pacer} exceeds {PACER_INTERVAL_CEIL_THRESHOLD} maximum threshold!")
-            if failed_tags > 1: # Fail the test on ceil threshold only when more than one tag failed
+            if failed_tags/tags_count > 0.2: # Fail the test on ceil threshold only when more than 20 %  tag failed
                 test.rc = TEST_FAILED
 
     # PASS test if only 1 tag out of many failed - this could be an issue with the tag
@@ -523,12 +527,14 @@ def scan_for_mgmt_pkts(test, mgmt_type):
         print_update_wait()
         pkts_collected = cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=mgmt_type)
         if pkts_collected:
-            utPrint("Found brg2gw_mgmt_pkts:", "GREEN")
+            #TODO: logging print 
+            # utPrint("Found brg2gw_mgmt_pkts:", "GREEN")
             seq_ids = []
             for p in pkts_collected:
                 if seq_ids == [] or p[SEQUENCE_ID] not in seq_ids:
                     seq_ids.append(p[SEQUENCE_ID])
-                    print(p[MGMT_PKT].pkt)
+                    #TODO: Logging print 
+                    # print(p[MGMT_PKT].pkt)
                     ret_pkts.append(p)
             found = True
             break
@@ -591,7 +597,7 @@ def display_data(df, csv=True, nfpkt=False, pkt_cntr_diff=False, cer_per_tag=Fal
             f.write(g.to_html(full_html=False, include_plotlyjs='cdn', include_mathjax='cdn'))
             f.write("<br>")
     if csv:
-        df.to_csv(os.path.join(dir, f"{name_prefix}all_data.csv"), index=False)
+        df.to_csv(os.path.join(BASE_DIR, dir, f"{name_prefix}all_data.csv"), index=False)
 
     return ttfp_graph
 
@@ -599,7 +605,11 @@ def single_log_search(test, s, found, fail_on_find=False, print_logs=True, addit
     res = False
     for p in test.mqttc._userdata[PKTS].status:
         if GW_LOGS in p.body:
-            logs = p.body[GW_LOGS][LOGS] if test.protobuf else p.body[GW_LOGS]
+            if test.protobuf and p.body[GW_LOGS]:
+                # handle protobuf structure (when GW_LOGS is not empty)
+                logs = p.body[GW_LOGS][LOGS]
+            else:
+                logs = p.body[GW_LOGS]
             for log in logs:
                 if any([s in log]) and any([additional_log in log]) and (log not in found):
                     print(f"Log: {log}, Additional Log: {additional_log}")
@@ -713,25 +723,6 @@ def get_cfg_hash(test):
     else:
         return test, module_if_pkt.cfg_hash
 
-def module_ack_search(test, test_pkt, mgmt_type, wait=True):
-    """
-    module ack search
-    wait=False is for pwr mgmt off - in order to send the "off" pkt repeatidly while searching for the ack
-    """
-    if wait:
-        test, mgmt_pkts = scan_for_mgmt_pkts(test, [mgmt_type])
-    else:
-        mgmt_pkts = cert_mqtt.get_brg2gw_mgmt_pkts(test.mqttc, test, mgmt_types=[mgmt_type])
-    if not test.rc:
-        for p in mgmt_pkts:
-            pkt = p[MGMT_PKT].pkt
-            if (pkt == test_pkt.pkt):
-                return test, True
-        if wait:
-            test.rc = TEST_FAILED
-            test.add_reason(f"{mgmt_type} module does not match pkt received")
-            print(test.reason)
-    return test, False
 
 def brg_restore_defaults_check(test):
     print("Starting Restore Defaults Check")
@@ -777,8 +768,7 @@ def brg_pwr_mgmt_turn_on(test):
                                                       brg_mac=test.active_brg.id_int, static_on_duration=30, static_sleep_duration=60,
                                                       dynamic_leds_on=0,dynamic_keep_alive_period=0, dynamic_keep_alive_scan=0,
                                                       dynamic_on_duration=0,dynamic_sleep_duration=0))
-    cert_config.gw_downlink(test, raw_tx_data=wltpkt.dump())
-    test = module_ack_search(test, test_pkt=wltpkt, mgmt_type=module)[0]
+    test = cert_config.brg_configure(test=test, cfg_pkt=wltpkt, module=module)[0]
 
     if test.rc == TEST_FAILED:
         test.add_reason("Turning pwr mgmt ON failed, Didn't receive GW MEL pwr mgmt ON pkt")
@@ -797,16 +787,15 @@ def brg_pwr_mgmt_turn_off(test):
                                                       static_on_duration=0,static_sleep_duration=0,
                                                       dynamic_leds_on=0,dynamic_keep_alive_period=0,
                                                       dynamic_keep_alive_scan=0,dynamic_on_duration=0,dynamic_sleep_duration=0))
-    found = False
-    while not found:
-        cert_config.gw_downlink(test, raw_tx_data=wltpkt.dump())
-        test, found = module_ack_search(test, wltpkt, module, wait=False)
+    found = NOT_FOUND
+    while found != DONE:
+        test, found = cert_config.brg_configure(test=test, cfg_pkt=wltpkt, module=module, wait=False)
         if ((datetime.datetime.now() - start_time).seconds > (ag.PWR_MGMT_DEFAULTS_KEEP_ALIVE_PERIOD + 1)):
             test.add_reason(f"Didn't receive GW MEL pwr mgmt OFF ack after {ag.PWR_MGMT_DEFAULTS_KEEP_ALIVE_PERIOD + 1} seconds")
             test.rc = TEST_FAILED
             break
         print_update_wait()
-    if found:
+    if found == DONE:
         utPrint(f"FOUND off pkt after {(datetime.datetime.now() - start_time)} secs", "GREEN")
         utPrint("SUCCESS! pwr mgmt static mode turned off!", "GREEN")
     return test

brg_certificate/cert_config.py

@@ -64,7 +64,8 @@ def create_gw_config(test, cfg, version=""):
 
 def gw_downlink(test, raw_tx_data="", is_ota=False, version="", max_duration=100, max_retries=8):
     pkt = create_gw_downlink_pkt(test, raw_tx_data, is_ota, version=version, max_duration=max_duration, max_retries=max_retries)
-    print("GW Downlink:", pkt)
+    #TODO: logging print
+    # print("GW Downlink:", pkt)
     payload = cert_protobuf.downlink_to_pb(pkt) if test.protobuf else json.dumps(pkt)
     test.mqttc.publish(test.mqttc.update_topic, payload=payload, qos=1)
 
@@ -73,9 +74,9 @@ def create_gw_downlink_pkt(test, raw_tx_data="", is_ota=False, version="", max_d
                 TX_MAX_DURATION_MS: max_duration,
                 TX_MAX_RETRIES: max_retries})
     if is_ota == False:
-        ret[ACTION] = 0
+        ret[ACTION] = ACTION_ADVERTISING
     else:
-        ret[ACTION] = 1
+        ret[ACTION] = ACTION_BRG_OTA
         ret[GW_ID] = str(test.gw)
         ret[BRIDGE_ID] = test.active_brg.id_str
         ret[IMG_DIR_URL] = f"https://api.us-east-2.prod.wiliot.cloud/v1/bridge/type/{test.active_brg.board_type}/version/{version}/binary/"
@@ -87,7 +88,7 @@ def create_gw_downlink_pkt(test, raw_tx_data="", is_ota=False, version="", max_d
 
 def get_default_gw_dict(test=None):
     return dict({WLT_SERVER: test.server if test else PROD, GW_MODE: BLE_WIFI, USE_STAT_LOC: False,
-                 SERIALIZATION_FORMAT: PROTOBUF})
+                 SERIALIZATION_FORMAT: PROTOBUF, ACL:dict({ACL_MODE: ACL_DENY , ACL_BRIDGE_IDS:[]})})
 
 def config_gw_defaults(test, version=""):
     utPrint(f"Configuring gateway {test.gw} to defaults", "BLUE")
@@ -262,7 +263,8 @@ def internal_brg_configure(test, cfg_pkt=None, module=None, fields=None, values=
     return test, res
 
 def send_brg_action(test, action_id, **kwargs):
-    print(f"\nSending {ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version} with parameters={kwargs if kwargs else None}")
+    #TODO: logging print
+    # print(f"\nSending {ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version} with parameters={kwargs if kwargs else None}")
     test.mqttc.flush_pkts()
     action_pkt = get_default_brg_pkt(test, pkt_type=eval_pkt(f'{ag.ACTIONS_DICT[action_id]}{test.active_brg.api_version}'), **kwargs)
     gw_downlink(test, raw_tx_data=action_pkt.dump())

brg_certificate/cert_data_sim.py

@@ -144,16 +144,26 @@ class DataSimThread(threading.Thread):
         self.delay = delay
         self.pkt_types = pkt_types
         self._stop_event = threading.Event()
+        self._pause_event = threading.Event()
+        self._pause_event.set()
         self.daemon = True
 
     def run(self):
         write_to_data_sim_log_file(f"num_of_pixels={self.num_of_pixels} duplicates={self.duplicates} delay={self.delay} pkt_types={self.pkt_types}\n")
         # Run pixel_sim loop
         while not self._stop_event.is_set():
+            self._pause_event.wait()
             for i in range(self.num_of_pixels):
+                if self._stop_event.is_set():
+                    return  
+                if not self._pause_event.is_set():
+                    break
                 for pkt_type in self.pkt_types:
+                    if not self._pause_event.is_set():
+                        break
                     pkt = self.pixels[i]
                     pkt.set_pkt_type(pkt_type)
+
                     # Set pkt_id, in Gen3 pkt_type_1 has pkt_id_0+1
                     if type(pkt) == WiliotPixelGen3:
                         if pkt_type == 1:
@@ -175,14 +185,26 @@ class DataSimThread(threading.Thread):
                         TX_MAX_RETRIES: self.duplicates,
                         TX_MAX_DURATION_MS: 100,
                         ACTION: 0}
-                    if self.test.protobuf == True:
+                    # Use protobuf if protubuf flag is set to True AND data sim does not use a gw simulator board
+                    if self.test.protobuf == True and not self.test.gw_sim:
                         payload = cert_protobuf.downlink_to_pb(msg)
                     else:
                         payload = json.dumps(msg)
-                    self.test.mqttc.publish(self.test.mqttc.update_topic, payload=payload)
+                    self.test.sim_mqttc.publish(self.test.sim_mqttc.update_topic, payload=payload)
                     write_to_data_sim_log_file(f"{pkt}" + " {}\n".format(datetime.datetime.now().strftime("%d/%m,%H:%M:%S.%f")[:-4]))
                     actual_delay = max(self.delay, self.duplicates*(PIXEL_SIM_MIN_CYCLE))
                     time.sleep(actual_delay/1000)
-
     def stop(self):
-        self._stop_event.set()
+        """Stops the thread completely"""
+        self._stop_event.set()
+        write_to_data_sim_log_file(f"DataSimThread stopped\n")
+
+    def pause(self):
+        """Pauses the thread execution"""
+        self._pause_event.clear()
+        write_to_data_sim_log_file(f"DataSimThread paused\n")
+
+    def resume(self):
+        """Resumes the thread execution"""
+        self._pause_event.set()
+        write_to_data_sim_log_file(f"DataSimThread resumed\n")

brg_certificate/cert_defines.py

@@ -1,7 +1,13 @@
 # Files
 import os
+import importlib.metadata
 # BASE_DIR should be initiated in the same dir as brg_certificate.py
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+# CERT_VERSION handling - local/PyPi
+if hasattr(importlib.metadata,'packages_distributions') and "wiliot-certificate" in importlib.metadata.packages_distributions():
+    CERT_VERSION = importlib.metadata.version("wiliot-certificate")
+else:
+    CERT_VERSION = "local-dev"
 CERT_MQTT_LOG_FILE =            "cert_mqtt_log.json"
 DATA_SIM_LOG_FILE =             "data_sim_log.txt"
 UT_RESULT_FILE_HTML =           "results.html"
@@ -60,6 +66,15 @@ PROD =                          "prod"
 SERIALIZATION_FORMAT =          "serializationFormat"
 PROTOBUF =                      "Protobuf"
 JSON =                          "JSON"
+ACL =                           "accessControlList"
+ACL_MODE =                      "mode"
+ACL_MODE_ALLOW =                "mode_allow"
+ACL_BRIDGE_IDS =                "bridgeIds"
+ACL_IDS =                       "ids"
+ACL_DENY =                      "deny"
+ACL_ALLOW =                     "allow"
+ACL_DENY_VALUE =                 0
+ACL_ALLOW_VALUE =                1
 
 GET_INFO_ACTION =               "getGwInfo"
 REBOOT_GW_ACTION =              "rebootGw"
@@ -78,9 +93,12 @@ TX_PKT =                        "txPacket"
 TX_MAX_DURATION_MS =            "txMaxDurationMs"
 TX_MAX_RETRIES =                "txMaxRetries"
 TRANPARENT_PKT_LEN =            31 * 2
+ACTION_ADVERTISING =            0
+ACTION_BRG_OTA =                1
 
 # Simulator defines
 GW_SIM_BLE_MAC_ADDRESS =       'GW_SIM_BLE_MAC_ADDRESS'
+GW_APP_VERSION_HEADER =        'WILIOT_GW_BLE_CHIP_SW_VER'
 GW_SIM_PREFIX =                'SIM'
 DATA_SIMULATION =              'sim'
 DATA_REAL_TAGS =               'tags'
@@ -135,6 +153,8 @@ NUM_VAL =                       "numberValue"
 GW_STATUS =                     "gatewayStatus"
 BRG_UPGRADE =                   "bridgeUpgrade"
 REBOOT_PKT =                    "rebootPacket"
+CONFIG =                        "config"
+ACL_VALUE =                     "aclValue"
 
 # Custom broker
 CUSTOM_BROKER_ENABLE       = "customBroker"
@@ -160,6 +180,8 @@ STATUS_CODE =                    "status" # Protobuf
 IMG_DIR_URL =                    "imageDirUrl"
 UPGRADE_BLSD =                   "upgradeBlSd"
 VER_UUID_STR =                   "versionUUID"
+STEP =                           "step"
+PROGRESS =                       "progress"
 VER_MAX_LEN =                    31
 
 # Versions
@@ -197,6 +219,7 @@ GW_LONGITUDE_DEFAULT =              -117.0839
 # Set to work with default when versions tests only pass through new api ver
 GW_API_VER_DEFAULT =                "201"
 GW_API_VER_OLD =                    "200"
+GW_API_VER_LATEST =                 "205"
 BRG_CFG_HAS_LEN =                   2
 CLEAR_DATA_PATH_TIMEOUT =           10
 ACTION_LONG_TIMEOUT =               120
@@ -215,8 +238,8 @@ TEST_FAILED =                                       -1
 TEST_SKIPPED =                                      1
 TEST_INIT =                                         2
 NO_RESPONSE =                                       "NO_RESPONSE"
+NOT_FOUND =                                         "NOT_FOUND"
 DONE =                                              "DONE"
-TEST_SUCCESS =                                      ":)"
 MGMT_PKT =                                          "mgmt_pkt"
 UNIFIED_PKT =                                       "unified_pkt"
 SIDE_INFO_SENSOR_PKT =                              "side_info_sensor_pkt"
@@ -239,10 +262,14 @@ AWS =                                               "aws"
 TEST =                                              "test"
 MULTI_BRG_TEST =                                    "multiBridgeTest" # used for multi brg tests
 GW_ONLY_TEST =                                      "gwOnlyTest" # used for gw only tests
+INTERNAL_BRG =                                      "internalBridge"
+PURPOSE =                                           "purpose"
+MANDATORY =                                         "mandatory"
+DOCUMENTATION =                                     "documentation"
 ALL_SUPPORTED_VALUES =                              "allSupportedValues"
-PROLOG =                                            "Prolog"
+PRE_CONFIG =                                        "Pre config"
 TEST_BODY =                                         "Test Body"
-EPILOG =                                            "Epilog"
+RESTORE_CONFIG =                                    "Restore config"
 
 # test reasons
 NO_PARAMS_GIVEN =           "No parameters given!"

brg_certificate/cert_gw_sim.py

@@ -13,7 +13,6 @@ import brg_certificate.cert_utils as cert_utils
 
 # Generic Defines
 SERIAL_TIMEOUT =                                    0.1 # TODO decide about the right value
-GW_APP_VERSION_HEADER =                             'WILIOT_GW_BLE_CHIP_SW_VER'
 STOP_ADVERTISING =                                  '!stop_advertising'
 RESET_GW =                                          '!reset'
 DEDUPLICATION_PKTS =                                '!deduplication_pkts'
@@ -82,19 +81,20 @@ def prep_gw(args, mqttc, start_time):
     gw = args.gw
     protobuf = False
     internal_brg_mac_addr = os.getenv(GW_SIM_BLE_MAC_ADDRESS)
+    internal_brg_ble_ver = os.getenv(GW_APP_VERSION_HEADER)
     if not internal_brg_mac_addr:
         cert_utils.handle_error(f"ERROR: Didn't receive {GW_SIM_BLE_MAC_ADDRESS} response!", start_time)
     internal_brg = cert_utils.ut_prep_brg(args, mqttc, start_time, gw, internal_brg_mac_addr, "prod", protobuf)
     if internal_brg.api_version != ag.API_VERSION_LATEST:
         cert_utils.handle_error(f"ERROR: Certificate FW api_version={internal_brg.api_version} instead of api_version={ag.API_VERSION_LATEST}! Please upgrade the FW!", start_time)
-    return gw, internal_brg, "prod", {BLE_VERSION:"0.0.0", WIFI_VERSION:"0.0.0"}, protobuf
+    return gw, internal_brg, "prod", {BLE_VERSION:internal_brg_ble_ver, WIFI_VERSION:"0.0.0"}, protobuf
 
 ##############################################
 # UART FUNCTIONS
 ##############################################
 def write_to_ble(ble_serial, txt, print_enable=True, sleep=0):
-    if print_enable:
-        print('\n' + txt)
+    # if print_enable:
+    #     print('\n' + txt)
     ble_serial.write(bytes(txt, encoding='utf-8') + b'\r\n')
     if sleep:
         cert_common.wait_time_n_print(sleep)
@@ -113,9 +113,10 @@ def gw_app_reponse(ble_serial):
         input = read_from_ble(ble_serial)
         if GW_APP_VERSION_HEADER in input:
             print(input)
-            ble_mac_address = re.search('WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
+            ble_chip_sw_ver = re.search(r'WILIOT_GW_BLE_CHIP_SW_VER=(\d+\.\d+\.\d+)', input).group(1)
+            ble_mac_address = re.search(r'WILIOT_GW_BLE_CHIP_MAC_ADDRESS=([0-9A-F]{12})', input).group(1)
             print("success!")
-            return TEST_PASSED, ble_mac_address
+            return TEST_PASSED, ble_mac_address, ble_chip_sw_ver
     print("failure!")
     return TEST_FAILED, ''
 
@@ -192,8 +193,10 @@ def on_unsubscribe(mqttc, userdata, mid):
 def on_message(client, userdata, message):
     data = json.loads(message.payload.decode("utf-8"))
     print_enable = True if not PIXEL_SIM_INDICATOR in str(message.payload.decode("utf-8")) else False
-    if print_enable:
-        print("##########\n// Message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
+    # if print_enable:
+    #     print("##########\n// Message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
+    #     #TODO: logging print
+    #     # print("##########\n// Message received at {}, topic={}:\n{}\n".format(datetime.datetime.now().strftime("%d/%m/%Y, %H:%M:%S"), message.topic, str(message.payload.decode("utf-8"))))
     # Send packet to UART
     if TX_PKT in data:
         # Downlink packet
@@ -264,6 +267,7 @@ def gw_sim_run(port, gw_id, analyze_interference=False):
         print("ERROR: didn't get version response!")
         return
     os.environ[GW_SIM_BLE_MAC_ADDRESS] = gw_app_res[1]
+    os.environ[GW_APP_VERSION_HEADER] = gw_app_res[2]
     write_to_ble(ble_serial, STOP_ADVERTISING, sleep=2)
     write_to_ble(ble_serial, f"{CONNECTIVITY_STATUS} 1 1")
 

brg_certificate/cert_mqtt.py

@@ -170,6 +170,13 @@ def on_message_protobuf(mqttc, userdata, message):
     if pb_decoded is True:
         pb_msg_dict = MessageToDict(pb_msg)
         # Align formats with JSON (bytes to hex strings)
+        if 'status' in message.topic:
+            if ACTION_STATUS in pb_msg_dict:
+                pb_msg_dict[ACTION_STATUS][BRIDGE_ID] = base64.b64decode(pb_msg_dict[ACTION_STATUS][BRIDGE_ID]).hex().upper()
+            if GW_STATUS in pb_msg_dict and ACL_IDS in pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE]:
+                ids_list = pb_msg_dict[GW_STATUS][CONFIG][ACL][ACL_VALUE][ACL_IDS]
+                for idx, id in enumerate(ids_list):
+                    ids_list[idx] = base64.b64decode(id).hex().upper()
         if 'data' in message.topic and PACKETS in pb_msg_dict.keys():
             for idx, pkt in enumerate(pb_msg_dict[PACKETS]):
                 pb_msg_dict[PACKETS][idx][PAYLOAD] = base64.b64decode(pkt[PAYLOAD]).hex().upper()
@@ -353,13 +360,14 @@ def get_brg2gw_mgmt_pkts(mqttc, test=None, mgmt_types=[]):
     pkts = [p for p in brg2gw_mgmt_pkts if test.active_brg.id_str in p[PAYLOAD]]
     return pkts
 
-def get_unified_data_pkts(test):
+def get_unified_data_pkts(test, only_active_brg=True):
     all_unified_pkts, pkts = [], get_all_sim_data_pkts(test.mqttc) if test.data == DATA_SIMULATION else get_all_data_pkts(test.mqttc)
     for p in pkts:
         if UNIFIED_PKT in p:
             all_unified_pkts += [p]
     pkts = all_unified_pkts
-    pkts = [p for p in all_unified_pkts if p[ALIAS_BRIDGE_ID] == test.active_brg.id_alias]
+    if only_active_brg:
+        pkts = [p for p in all_unified_pkts if p[ALIAS_BRIDGE_ID] == test.active_brg.id_alias]
     print(f"\nCollected {len(pkts)} unified data pkts")
     return pkts
 

brg_certificate/cert_prints.py

@@ -22,11 +22,13 @@ color = lambda c, t : COLORS["BOLD"]+COLORS[c]+t+COLORS["ENDC"]
 pipeline_running = lambda : True if 'BITBUCKET_BUILD_NUMBER' in os.environ else False
 camelcase_to_title = lambda s: ' '.join(word.capitalize() for word in re.split('(?=[A-Z])', s))
 SEP = '\n' + '#'*100 + '\n'
-WIL_UT_TEXT = r'''
-__      _____ _    ___ ___ _____   _   _ _____
-\ \    / /_ _| |  |_ _/ _ \_   _| | | | |_   _|
- \ \/\/ / | || |__ | | (_) || |   | |_| | | |
-  \_/\_/ |___|____|___\___/ |_|    \___/  |_|
+WIL_CERT_TEXT = r'''
+ __        _____ _     ___ ___ _____    ____ _____ ____ _____ ___ _____ ___ ____    _  _____ _____ 
+ \ \      / /_ _| |   |_ _/ _ \_   _|  / ___| ____|  _ \_   _|_ _|  ___|_ _/ ___|  / \|_   _| ____|
+  \ \ /\ / / | || |    | | | | || |   | |   |  _| | |_) || |  | || |_   | | |     / _ \ | | |  _|  
+   \ V  V /  | || |___ | | |_| || |   | |___| |___|  _ < | |  | ||  _|  | | |___ / ___ \| | | |___ 
+    \_/\_/  |___|_____|___\___/ |_|    \____|_____|_| \_\|_| |___|_|   |___\____/_/   \_\_| |_____|
+                                                                                                   
 '''
 
 hex_str2int = lambda s : int(s, 16)

brg_certificate/cert_protobuf.py

@@ -39,7 +39,7 @@ def gw_cfg_pb(msg: dict):
         # Skip GW_MODE since it doesn't exist today and harm the parsing in PB
         if GW_MODE == key:
             continue
-        pb_value = wpb.Value()
+        pb_value = wpb.GatewayConfigValue()
         if isinstance(val, int):
             pb_value.integerValue = val
         elif isinstance(val, float):
@@ -48,6 +48,10 @@ def gw_cfg_pb(msg: dict):
             pb_value.stringValue = val
         elif isinstance(val, bool):
             pb_value.boolValue = val
+        elif isinstance(val, dict) and key == ACL:
+            pb_value.aclValue.mode_allow = ACL_DENY_VALUE if msg[ADDITIONAL][ACL][ACL_MODE] == ACL_DENY else ACL_ALLOW_VALUE
+            ids_bytes = [bytes.fromhex(id) for id in msg[ADDITIONAL][ACL][ACL_BRIDGE_IDS]]
+            pb_value.aclValue.ids.extend(ids_bytes)
         else:
             raise ValueError(f"Unsupported value type for key '{key}': {type(val)}")
         pb_msg.gatewayConfig.config[key].CopyFrom(pb_value)