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

gw_certificate/tests/actions.py

@@ -1,289 +0,0 @@
-import datetime
-import os
-import time
-import pandas as pd
-
-from packaging import version
-
-from gw_certificate.common.debug import debug_print
-from gw_certificate.interface.mqtt import MqttClient, GwAction
-from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, INCONCLUSIVE_MINIMUM, GenericTest, GenericStage, OPTIONAL
-from gw_certificate.tests.static.references import GW_ACTIONS_DOC, GW_BRIDGE_OTA_DOC
-from gw_certificate.ag.ut_defines import STATUS_CODE_STR
-from gw_certificate.interface.uart_if import FIRST_UNIFIED_BL_VERSION, UARTError
-
-
-BL_INACTIVITY_TIMEOUT_SEC = 120
-
-
-class GenericActionsStage(GenericStage):
-    def __init__(self, mqttc:MqttClient, stage_name, **kwargs):
-        self.__dict__.update(kwargs)
-        super().__init__(stage_name=stage_name, **self.__dict__)        
-        
-        #Clients
-        self.mqttc = mqttc
-        
-        #Stage Params
-        self.action = ""
-        
-        #Paths
-        self.summary_csv_path = os.path.join(self.test_dir, f'{self.stage_name}_summary.csv')
-
-        
-    def prepare_stage(self):
-        super().prepare_stage()
-        self.mqttc.flush_messages()
-    
-    def generate_stage_report(self):
-        self.add_report_header()
-
-class GatewayInfoStage(GenericActionsStage):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs, stage_name=type(self).__name__)
-        self.stage_tooltip = "Issues a Gateway Info action to the gateway. Expects the gateway to publish a response"
-        self.error_summary = "Did not receive a response to the Gateway Info action"
-        self.action = "getGwInfo"
-        self.response = None
-    
-    def run(self):
-        super().run()
-        timeout = datetime.datetime.now() + datetime.timedelta(seconds=20)
-        self.gw_info = None
-        self.mqttc.flush_messages()
-
-        self.mqttc.send_action(GwAction.GET_GW_INFO)
-        while datetime.datetime.now() < timeout and self.gw_info is None:
-            self.gw_info = self.mqttc.get_gw_info_message()
-            time.sleep(5)
-
-
-    def generate_stage_report(self):
-        super().generate_stage_report()
-
-        # Calculate whether stage pass/failed
-        if self.gw_info == None:
-            self.stage_pass = MINIMUM_SCORE
-            self.add_to_stage_report(f'Did not receive a response to the Gateway Info action. For more info visit:')
-            self.add_to_stage_report(f'{GW_ACTIONS_DOC}')
-        else:
-            self.stage_pass = PERFECT_SCORE
-            self.response = repr(self.gw_info)
-            self.add_to_stage_report('A Gateway Info response was receieved:')
-            self.add_to_stage_report(self.response)
-
-        # Export all stage data
-        csv_data = {'Action': [self.action], 'Response': [self.response], 'Pass': [self.stage_pass > self.pass_min]}
-        pd.DataFrame(csv_data).to_csv(self.summary_csv_path)
-        self.add_to_stage_report(f'\nStage summary saved - {self.summary_csv_path}')
-        debug_print(self.report)
-        
-        # Generate HTML
-        self.report_html = self.template_engine.render_template('stage.html', stage=self, 
-                                                                stage_report=self.report.split('\n'))
-        return self.report
-
-
-class RebootStage(GenericActionsStage):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs, stage_name=type(self).__name__)
-        self.stage_tooltip = "Issues reboot action to the gateway. Expects it to reboot"
-        self.error_summary = "The gateway did not reboot as expected"
-        self.action = "rebootGw"
-    
-    def run(self):
-        super().run()
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=3)
-        self.status_message = None
-
-        debug_print("Sending a reboot action to the gateway and awaiting reboot.. (timeout = 3)")
-        self.mqttc.send_action(GwAction.REBOOT_GW)
-        while datetime.datetime.now() < timeout and self.status_message is None:
-            self.status_message = self.mqttc.get_status_message()
-            time.sleep(5)
-
-    def generate_stage_report(self):
-        super().generate_stage_report()
-
-        # Calculate whether stage pass/failed
-        if self.status_message is None:
-            self.stage_pass = MINIMUM_SCORE
-            self.add_to_stage_report(f"The gateway did not validly reboot")
-            self.add_to_stage_report(f"Gateways are expected to upload a status(configuration) message upon establishing MQTT connection, which wasn't received.")
-        else:
-            self.stage_pass = PERFECT_SCORE
-            self.add_to_stage_report(f"Gateway rebooted and uploaded a configuration message, as expected.")
-        
-        # Export all stage data
-        csv_data = {'Action': [self.action], 'Pass': [self.stage_pass > self.pass_min]}
-        pd.DataFrame(csv_data).to_csv(self.summary_csv_path)
-        self.add_to_stage_report(f'\nStage summary saved - {self.summary_csv_path}')
-
-        # Generate HTML
-        self.report_html = self.template_engine.render_template('stage.html', stage=self, 
-                                                                stage_report=self.report.split('\n'))
-        return self.report
-
-class BridgeOTAStage(GenericActionsStage):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs, stage_name=type(self).__name__)
-        self.stage_tooltip = "Issues a bridge OTA action to the gateway. Expects it to upgrade the bridge"
-        self.error_summary = "Bridge wasn't upgraded."
-        self.action = "Bridge Upgrade"
-
-        OTA_VERSIONS_TO_USE = ("4.4.91", "4.4.92")
-        if version.parse(OTA_VERSIONS_TO_USE[0]) != self.uart.fw_version:
-            self.desired_version = version.parse(OTA_VERSIONS_TO_USE[0])
-        else:
-            self.desired_version = version.parse(OTA_VERSIONS_TO_USE[1])
-    
-    def prepare_stage(self):
-        super().prepare_stage()
-        debug_print(f"Important: For the gateway to be able to download the file, it must use a valid token in the HTTP GET request.")
-        debug_print(f"Meaning It must be registered under an owner, and the certificate '-env' should correspond to that owner.")
-        debug_print(f"BridgeOTAStage attempt: {str(self.uart.fw_version)} -> {str(self.desired_version)}")
-        # Reset to remove any log/cert mode we had in the kit so it behaves as a bridge
-        self.uart.reset_gw()
-    
-    def is_final_action_status(self, msg):
-        LAST_OTA_STEP = 7
-        if not isinstance(msg, dict):
-            return False
-
-        step = msg.get('step')
-        progress = msg.get('progress')
-        status = msg.get('statusCode')
-        if status == None:
-            # Both json/pb
-            status = msg.get('status')
-
-        if step == None:
-            # Old action status
-            if status != None:
-                return True
-        else:
-            # New progress action status
-            if (step == LAST_OTA_STEP and progress == 100) or (status != 0):
-                return True
-        return False
-
-    def run(self):
-        super().run()
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=10)
-        self.action_status = None
-        self.status_code = None
-        self.reboot_packet_ts = None
-        self.action_status_ts = None
-
-        self.mqttc.send_bridge_ota_action(self.uart.mac, str(self.desired_version), 200, False, self.gw_id, "aws", self.env)
-        debug_print("Sent a BridgeOTA action to the gateway")
-        debug_print("Waiting for an actionStatus message from the gateway... (timeout=10)")
-
-        while datetime.datetime.now() < timeout and self.action_status is None:
-            line = self.uart.read_line()
-            if line != None and 'reset' in line:
-                self.reboot_packet_ts = datetime.datetime.now()
-                debug_print("A reboot packet was received by the bridge")
-                self.uart.reset_gw(stop_advertising=False)
-
-            # Ignoring progress report until test supported
-            msg = self.mqttc.get_action_status_message()
-            if self.is_final_action_status(msg):
-                self.action_status = msg
-            time.sleep(2)
-        
-        debug_print(f'{self.action_status}')
-        if self.action_status != None:
-            debug_print("actionStatus was received from the gateway")
-            self.action_status_ts = datetime.datetime.now()
-            self.status_code = self.action_status.get(STATUS_CODE_STR)
-            if self.status_code == None:
-                self.status_code = self.action_status.get('status')
-            
-            if self.status_code != 0 and self.reboot_packet_ts != None:
-                debug_print(f"Reported status {self.status_code} indicates failure, waiting for the bridge bootloader inactivity timer (2 minutes)..")
-                time.sleep(BL_INACTIVITY_TIMEOUT_SEC)
-
-            debug_print('Waiting for the bridge to boot...')
-            time.sleep(40)
-
-        cur_ver = self.uart.get_version()
-        if cur_ver == None:
-            debug_print("ERROR: The certificate kit, acting as bridge in this stage, is not responding.")
-            self.uart.flush(request_power_cycle=True)
-            cur_ver = self.uart.get_version()
-            if cur_ver == None:
-                raise UARTError("Communication to the certificate kit halted! "
-                                "Please unplug and replug its power source, wait for 5 minutes and retry. "
-                                "If the error persist, contact Wiliot Support and attach your results directory.")
-        self.current_version = version.parse(cur_ver)
-
-    def generate_stage_report(self):
-        super().generate_stage_report()
-
-        # Calculate whether stage pass/failed
-        if self.action_status is None or self.status_code != 0:
-            debug_print("Failed to receive an actionStatus message.")
-            self.stage_pass = MINIMUM_SCORE
-            self.add_to_stage_report(f"The bridge OTA test failed")
-            if self.action_status is None:
-                self.add_to_stage_report(f"Gateways are expected to upload an actionStatus message upon establishing MQTT connection, which wasn't received.")
-            elif self.status_code is None:
-                self.add_to_stage_report(f"Uploaded actionStatus messages should contain the status field, which wasn't detected.")
-            elif self.status_code != 0:
-                self.add_to_stage_report(f"Uploaded actionStatus status value received is {self.status_code}.")
-            if self.current_version == self.desired_version:
-                debug_print("Bridge was upgraded successfully")
-                self.error_summary = "Failed to receive actionStatus message."
-                self.add_to_stage_report(f"Note that the bridge was actually upgraded successfully.")
-                self.add_to_stage_report(f"Reboot packet received {(self.reboot_packet_ts - self.start_time).total_seconds():.1f}s after start.")
-            self.add_to_stage_report(f"{GW_BRIDGE_OTA_DOC}")
-        else:
-            if self.current_version == self.desired_version:
-                self.stage_pass = PERFECT_SCORE
-                debug_print("Bridge was upgraded successfully, actionStatus message received")
-                self.add_to_stage_report(f"Bridge was upgraded and an actionStatus message was received from the gateway.")
-                self.add_to_stage_report(f"Action status received {(self.action_status_ts - self.start_time).total_seconds():.1f}s after start.")
-                self.add_to_stage_report(f"Reboot packet received {(self.reboot_packet_ts - self.start_time).total_seconds():.1f}s after start.")
-                self.add_to_stage_report(f"Action status received {(self.action_status_ts - self.reboot_packet_ts).total_seconds():.1f}s after reboot.")
-            else:
-                self.stage_pass = MINIMUM_SCORE
-                debug_print("Bridge failed to upgrade")
-                self.add_to_stage_report(f"The bridge OTA test failed")
-                self.add_to_stage_report(f"Uploaded actionStatus message indicated success although the bridge was not upgraded.")
-
-        # Export all stage data
-        csv_data = {'Action': [self.action], 'Pass': [self.stage_pass > self.pass_min]}
-        if self.stage_pass == PERFECT_SCORE:
-            csv_data.update({'start_ts': self.start_time, 'reboot_packet_ts': self.reboot_packet_ts, 'action_status_ts': self.action_status_ts})
-        pd.DataFrame(csv_data).to_csv(self.summary_csv_path)
-        self.add_to_stage_report(f'\nStage summary saved - {self.summary_csv_path}')
-
-        # Generate HTML
-        self.report_html = self.template_engine.render_template('stage.html', stage=self, 
-                                                                stage_report=self.report.split('\n'))
-        return self.report
-
-ACTIONS_STAGES = [GatewayInfoStage, RebootStage, BridgeOTAStage]
-
-class ActionsTest(GenericTest):
-    def __init__(self, **kwargs):        
-        self.__dict__.update(kwargs)
-        super().__init__(**self.__dict__, test_name=type(self).__name__)
-        self.test_tooltip = "Stages publishing different actions (via the 'update' topic). Optional"
-        self.result_indication = OPTIONAL
-        # Actions stages are determined by the CLI argument
-        stages = self.actions
-
-        if BridgeOTAStage in stages and self.uart.fw_version < FIRST_UNIFIED_BL_VERSION:
-            debug_print("Certificate kit's firmware should be upgraded with the '-update' flag to run the BridgeOTAStage")
-            stages.remove(BridgeOTAStage)
-        self.stages = [stage(**self.__dict__) for stage in stages]
-    
-    def run(self):
-        super().run()
-        for stage in self.stages:
-            stage.prepare_stage()
-            stage.run()
-            self.add_to_test_report(stage.generate_stage_report())
-            self.test_pass = PassCriteria.calc_for_test(self, stage)

gw_certificate/tests/bad_crc_to_PER_quantization.csv

@@ -1,51 +0,0 @@
-bad_crc_percent,per_percent
-2,7
-4,11
-6,16
-8,20
-10,25
-12,29
-14,33
-16,37
-18,41
-20,45
-22,49
-24,52
-26,55
-28,58
-30,61
-32,64
-34,67
-36,69
-38,72
-40,74
-42,76
-44,78
-46,81
-48,83
-50,84
-52,86
-54,87
-56,89
-58,90.5
-60,91.5
-62,92.5
-64,93.5
-66,94.5
-68,95.5
-70,96.5
-72,97
-74,97.5
-76,98
-78,98.5
-80,99
-82,99.25
-84,99.5
-86,99.75
-88,100
-90,100
-92,100
-94,100
-96,100
-98,100
-100,100

gw_certificate/tests/connection.py

@@ -1,188 +0,0 @@
-import datetime
-import json
-import time
-import pkg_resources
-import pandas as pd
-from packaging import version
-
-from gw_certificate.tests.static.connection_defines import *
-from gw_certificate.common.debug import debug_print
-from gw_certificate.api_if.gw_capabilities import GWCapabilities
-from gw_certificate.tests.generic import INCONCLUSIVE_MINIMUM, PassCriteria, MINIMUM_SCORE, PERFECT_SCORE, GenericStage, GenericTest, INFORMATIVE
-from gw_certificate.api_if.api_validation import validate_message, MESSAGE_TYPES
-from gw_certificate.interface.mqtt import MqttClient, Serialization
-from gw_certificate.interface.ble_sniffer import BLESniffer, BLESnifferContext
-from gw_certificate.tests.static.references import GW_MQTT_DOC
-
-STATUS_MSG_TIMEOUT = 5
-
-class ConnectionStage(GenericStage):
-    def __init__(self, mqttc:MqttClient, **kwargs):
-        self.mqttc = mqttc
-        self.stage_tooltip = "Awaits the gateway to establish MQTT connection and upload it's configurations via the 'status' topic as it's first message"
-        self.__dict__.update(kwargs)
-        super().__init__(stage_name=type(self).__name__, **self.__dict__)
-
-    def run(self):
-        super().run()
-        self.stage_pass = MINIMUM_SCORE
-        input('The GW is expected to publish a configuration JSON/Protobuf message through the status topic upon connecting to mqtt:\n'
-                'Please unplug GW from power. Press enter when unplugged')
-        self.mqttc.flush_messages()
-        input('Please plug GW back to power. Press enter when plugged')
-        debug_print(f'Waiting for GW to connect... (Timeout {STATUS_MSG_TIMEOUT} minutes)')
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STATUS_MSG_TIMEOUT)
-        self.status_message = None
-
-        while datetime.datetime.now() < timeout and self.status_message is None:
-            time.sleep(2)
-            self.status_message = self.mqttc.get_status_message()
-
-        if self.status_message is not None:
-            ser = self.mqttc.get_serialization()
-            debug_print(self.status_message)
-            if ser == Serialization.JSON:
-                self.validation = validate_message(MESSAGE_TYPES.STATUS, self.status_message)
-                self.stage_pass = PERFECT_SCORE if self.validation[0] else MINIMUM_SCORE
-            else:
-                self.stage_pass = PERFECT_SCORE
-            # set GW Capabilities:
-            for key, value in self.status_message.items():
-                if key in GWCapabilities.get_capabilities() and type(value) is bool:
-                    self.gw_capabilities.set_capability(key, value)
-            self.cfg_data.status_msg_set(self.status_message, self.mqttc.get_serialization())
-
-    def generate_stage_report(self):
-        self.add_report_header()
-
-        if self.status_message is not None:
-            ser = self.mqttc.get_serialization()
-            debug_print(f'{ser.value} serialization detected')
-            self.add_to_stage_report(f'{ser.value} serialization detected')
-            self.add_to_stage_report('GW Status packet received:')
-            self.add_to_stage_report(f'{json.dumps(self.status_message)}\n')
-
-            for key, value in self.status_message.items():
-                if key in GWCapabilities.get_capabilities() and type(value) is bool:
-                    self.add_to_stage_report(f'Capability set: {key} - {value}')
-            # Add reason test failed to report if neccessary
-            if self.stage_pass == MINIMUM_SCORE:
-                self.error_summary = "API (JSON structure) is invalid. "
-                self.add_to_stage_report(f'\n{len(self.validation[1])} validation errors:')
-                for error in self.validation[1]:
-                    self.add_to_stage_report(error.message)
-                self.add_to_stage_report(f"Please look into the Status section in:\n{GW_MQTT_DOC}")
-
-            self.add_report_topic_validation('status')
-        else:
-            self.error_summary = f"No message recieved from GW in status topic after {STATUS_MSG_TIMEOUT} mins."
-            self.add_to_stage_report(self.error_summary)
-
-        self.report_html = self.template_engine.render_template('stage.html', stage=self,
-                                                                stage_report=self.report.split('\n'))
-        debug_print(self.report)
-        return super().generate_stage_report()
-    
-
-class InterferenceAnalysisStage(GenericStage):
-    def __init__(self, sniffer:BLESniffer, **kwargs):
-        self.sniffer = sniffer
-        self.conversion_table_df = None
-        self.stage_tooltip = "Analyze BLE interference level (Bad CRC %)"
-        self.__dict__.update(kwargs)
-
-        # Stage shows warning if CER is >=50%
-        self.result_indication = INFORMATIVE
-        self.pass_min = 51
-
-        super().__init__(stage_name=type(self).__name__, **self.__dict__)
-
-    def get_data_from_quantization_csv(self):
-        relative_path = CSV_NAME
-        csv_path = pkg_resources.resource_filename(__name__, relative_path)
-        conversion_table_df = pd.read_csv(csv_path)
-        self.conversion_table_df = conversion_table_df
-
-    def interference_analysis(self):
-        """Analyze the interference level (PER) before the test begins"""
-        self.report_buffer = []
-        
-        def handle_wrap_around(a):
-            "handle a wrap around of the counter"
-            if a < 0:
-                a = a + MAX_UNSIGNED_32_BIT
-            return a
-        
-        for channel in CHANNELS_TO_ANALYZE:
-            # Send the sniffer a command to retrive the counters and convert them to dict
-            start_cntrs = self.sniffer.get_pkts_cntrs(channel[0])
-            debug_print(f'Analyzing channel {channel[0]}... (30 seconds)')
-            time.sleep(CNTRS_LISTEN_TIME_SEC)
-            end_cntrs = self.sniffer.get_pkts_cntrs(channel[0])
-
-            if start_cntrs == None or end_cntrs == None:
-                debug_print(f'Channel {channel[0]} ({channel[1]} MHz) interference analysis was skipped beacause at least one counter is missing.')
-                self.report_buffer.append(f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference was not calculated, missing at least one counter.')
-                self.stage_pass = INCONCLUSIVE_MINIMUM
-                continue
-
-            # Calculate the bad CRC percentage
-            diff_dict = dict()
-            for key in CNTRS_KEYS:
-                diff_dict[key] = handle_wrap_around(end_cntrs[key] - start_cntrs[key])
-            if (diff_dict[WLT_RX] + diff_dict[NON_WLT_RX]) > 0:
-                bad_crc_percentage = round((diff_dict[BAD_CRC] / (diff_dict[WLT_RX] + diff_dict[NON_WLT_RX])) * 100)
-            else:
-                bad_crc_percentage = 0
-            self.report_buffer.append(f'Channel {channel[0]} ({channel[1]} MHz) Ambient Interference (bad CRC percentage) is: {bad_crc_percentage}%.')
-            self.report_buffer.append(f'Good CRC packets = {diff_dict[NON_WLT_RX] + diff_dict[WLT_RX] - diff_dict[BAD_CRC]}, bad CRC packets: {diff_dict[BAD_CRC]}')
-
-            good_crc_percentage = 100 - bad_crc_percentage
-            if (self.stage_pass == MINIMUM_SCORE) or (good_crc_percentage < self.stage_pass):
-                self.stage_pass = good_crc_percentage
-                if self.stage_pass < self.pass_min:
-                    self.error_summary = "High bad CRC rate within the current environment."
-        
-            # Uncomment if you want to see PER of the site (will require print adjustments). Below, we use the truth table from the csv to match PER the bad CRC percentage. Require an update of the CSV to the bridge-GW case
-            # closest_index = (self.conversion_table_df['bad_crc_percent'] - bad_crc_percentage).abs().idxmin()
-            # per_percent = self.conversion_table_df.iloc[closest_index]['per_percent']
-            # self.add_to_stage_report(f'Channel {channel} PER is: {per_percent}%')
-
-    def run(self):
-        super().run()
-        # Run interference analysis
-        # Note: there is an infrastructure for converting bad_CRC % to PER, currently unused and commented since the quantization_csv does not match the bridge to GW case.
-        debug_print(f"Starting interference analysis for channels {[ch[0] for ch in CHANNELS_TO_ANALYZE]}. This will take {30 * len(CHANNELS_TO_ANALYZE)} seconds (total)")
-        # self.get_data_from_quantization_csv()
-        self.interference_analysis()
-    
-    def generate_stage_report(self):
-        self.add_report_header()
-        for line in self.report_buffer:
-            self.add_to_stage_report(line)
-
-        self.report_html = self.template_engine.render_template('stage.html', stage=self,
-                                                                stage_report=self.report.split('\n'))
-        debug_print(self.report)
-        return super().generate_stage_report()
-
-STAGES = [ConnectionStage]
-
-class ConnectionTest(GenericTest):
-    def __init__(self, **kwargs):
-        self.test_tooltip = "Stages related to cloud connectivity and environment"
-        self.__dict__.update(kwargs)
-        super().__init__(**self.__dict__, test_name=type(self).__name__)
-        stages = STAGES
-        current_version = self.uart.get_version()
-        if current_version != None and version.parse(current_version) >= version.parse(INTERFERENCE_ANALYSIS_FW_VER):
-            stages.append(InterferenceAnalysisStage)
-        self.stages = [stage(**self.__dict__) for stage in stages]
-        
-    def run(self):
-        super().run()
-        for stage in self.stages:
-            stage.prepare_stage()
-            stage.run()
-            self.add_to_test_report(stage.generate_stage_report())
-            self.test_pass = PassCriteria.calc_for_test(self, stage)