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

gw_certificate/tests/downlink.py

@@ -1,172 +0,0 @@
-import base64
-import datetime
-import json
-import os
-import time
-import pandas as pd
-import plotly.express as px
-from google.protobuf.json_format import MessageToDict
-
-from gw_certificate.common import wltPb_pb2
-from gw_certificate.common.debug import debug_print
-from gw_certificate.interface.ble_sniffer import BLESniffer, BLESnifferContext
-from gw_certificate.interface.if_defines import RX_CHANNELS
-from gw_certificate.tests.static.downlink_defines import *
-from gw_certificate.interface.mqtt import MqttClient
-from gw_certificate.interface.pkt_generator import BrgPktGenerator
-from gw_certificate.tests.generic import PassCriteria, PERFECT_SCORE, MINIMUM_SCORE, INCONCLUSIVE_MINIMUM, GenericTest, GenericStage
-
-class GenericDownlinkStage(GenericStage):
-    def __init__(self, sniffer:BLESniffer, mqttc:MqttClient, pkt_gen:BrgPktGenerator, stage_name, **kwargs):
-        self.__dict__.update(kwargs)
-        super().__init__(stage_name=stage_name, **self.__dict__)        
-        
-        #Clients
-        self.sniffer = sniffer
-        self.mqttc = mqttc
-        self.pkt_gen = pkt_gen
-        
-        #Stage Params
-        self.sent_pkts = []
-        self.sniffed_pkts = pd.DataFrame()
-        
-        #Paths
-        self.sent_csv_path = os.path.join(self.test_dir, f'{self.stage_name}_sent.csv')
-        self.sniffed_csv_path = os.path.join(self.test_dir, f'{self.stage_name}_sniffed.csv')
-        self.graph_html_path = os.path.join(self.test_dir, f'{self.stage_name}.html')
-
-        
-    def prepare_stage(self):
-        super().prepare_stage()
-        self.sniffer.flush_pkts()
-    
-    def send_adv_payloads(self, tx_max_durations=TX_MAX_DURATIONS, retries=RETRIES):
-        sent_pkts = []
-        for tx_max_duration in tx_max_durations:
-            debug_print(f'Tx Max Duration {tx_max_duration}')
-            for retry in retries:
-                self.pkt_gen.increment_all()
-                brg_hb = self.pkt_gen.get_brg_hb()
-                tx_max_retries = tx_max_duration//100
-                sent_payload = self.mqttc.advertise_packet(raw_packet=brg_hb, tx_max_duration=tx_max_duration, use_retries=self.use_retries)
-                if isinstance(sent_payload, wltPb_pb2.DownlinkMessage):
-                    sent_payload = MessageToDict(sent_payload)
-                    # Decode b64-encoded bytes
-                    sent_payload['txPacket']['payload'] = base64.b64decode(sent_payload['txPacket']['payload']).hex().upper()
-                else:
-                    sent_payload = json.dumps(sent_payload)
-                debug_print(f'{sent_payload} sent to GW')
-                sent_pkts.append({'tx_max_duration': tx_max_duration, 'tx_max_retries': tx_max_retries,
-                                    'retry': retry, 'pkt': brg_hb[12:], 'payload': sent_payload, 'time_sent': datetime.datetime.now()})
-                time.sleep(max(MAX_RX_TX_PERIOD_SECS, (tx_max_duration/1000)*1.2))
-        time.sleep(10)
-        return sent_pkts
-        
-    def process_sniffed_pkts(self, sent_pkts, sniffer:BLESniffer):
-        for pkt in sent_pkts:
-            # Get vars from dict
-            raw_packet = pkt['pkt']
-            # Get packets from sniffer
-            sniffed_pkts = sniffer.get_filtered_packets(raw_packet=raw_packet)
-            pkt['channel'] = str(sniffer.rx_channel)
-            pkt['num_pkts_received'] = len(sniffed_pkts)
-            self.sniffed_pkts = pd.concat([self.sniffed_pkts, sniffed_pkts.to_pandas()])
-        self.sent_pkts += sent_pkts
-
-    def generate_stage_report(self):
-        # Create graph and trendline
-        self.add_report_header()
-        self.sent_pkts = pd.DataFrame(self.sent_pkts)
-        x_value = ('tx_max_duration', 'TX Max Duration') if not self.use_retries else ('tx_max_retries', 'TX Max Retries')
-        fig = px.scatter(self.sent_pkts, x=x_value[0], y='num_pkts_received', color='channel', title=f'Packets Received by Sniffer / {x_value[1]}',
-                         trendline='ols', labels={x_value[0]: x_value[1], 'num_pkts_received': 'Number of packets received', 'channel': "BLE Adv. Channel"})
-        fig.update_layout(scattermode="group", scattergap=0.95)
-        trendline_info = px.get_trendline_results(fig)
-        # Calculate whether stage pass/failed
-        self.stage_pass = PERFECT_SCORE
-        for channel, channel_df in trendline_info.groupby('BLE Adv. Channel'):
-            channel_pass = PERFECT_SCORE
-            channel_err_summary = ''
-            channel_pkts = self.sent_pkts[self.sent_pkts['channel'] == channel]
-            channel_trendline = channel_df['px_fit_results'].iloc[0]
-            slope = channel_trendline.params[1]
-            rsquared = channel_trendline.rsquared
-            # Determine Channel Pass
-            channel_pass, channel_err_summary = PassCriteria.calc_for_stage_downlink(rsquared, slope, self.stage_name, sum(channel_pkts['num_pkts_received']))
-            if channel_pass < self.stage_pass:
-                self.stage_pass = channel_pass
-                self.error_summary = channel_err_summary
-            self.add_to_stage_report(f"Channel {channel}: {PassCriteria.to_string(channel_pass)}")
-            self.add_to_stage_report(f"- Total {len(channel_pkts['payload'])} MQTT payloads sent")
-            self.add_to_stage_report(f"- Total {sum(channel_pkts['num_pkts_received'])} BLE Packets received by sniffer (including duplicates)")
-            self.add_to_stage_report(f"- R Value: {rsquared} | Slope: {slope}")
-        # Export all stage data
-        self.sent_pkts.to_csv(self.sent_csv_path)
-        self.add_to_stage_report(f'\nSent data saved - {self.sent_csv_path}')
-        self.sniffed_pkts.to_csv(self.sniffed_csv_path)
-        self.add_to_stage_report(f'Sniffed data saved - {self.sniffed_csv_path}')
-        fig.write_html(self.graph_html_path)
-        self.add_to_stage_report(f'Graph saved - {self.graph_html_path}')
-        debug_print(self.report)
-        
-        # Generate HTML
-        graph_div = fig.to_html(full_html=False, include_plotlyjs='cdn')
-        self.report_html = self.template_engine.render_template('stage.html', stage=self, 
-                                                                stage_report=self.report.split('\n'), graph = graph_div)
-        return self.report
-        
-class SanityStage(GenericDownlinkStage):
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
-        self.stage_tooltip = ("Verifies that the gateway advertises requested packets. "
-                              "These are requested via Advertisement actions published to the 'update' topic (MQTT)")
-        super().__init__(**self.__dict__, stage_name=type(self).__name__)
-
-    def run(self):                
-        super().run()
-        for channel in RX_CHANNELS:
-            debug_print(f'RX Channel {channel}')
-            with BLESnifferContext(self.sniffer, channel) as sniffer:
-                # Send the packets
-                sent_pkts = self.send_adv_payloads(STAGE_CONFIGS[SANITY_STAGE][0], STAGE_CONFIGS[SANITY_STAGE][1])
-                # Process sniffed packets
-                self.process_sniffed_pkts(sent_pkts, sniffer)
-        return True
-
-class CorrelationStage(GenericDownlinkStage):
-    def __init__(self, **kwargs):
-        self.__dict__.update(kwargs)
-        self.stage_tooltip = ("Checks how consistently the gateway advertises packets. "
-                              "Expects a consistently increasing packets count with increasing 'txMaxDuration'")
-        super().__init__(**self.__dict__, stage_name=type(self).__name__)
-
-    def run(self):                
-        super().run()
-        for channel in RX_CHANNELS:
-            debug_print(f'RX Channel {channel}')
-            with BLESnifferContext(self.sniffer, channel) as sniffer:
-                # Send the packets
-                sent_pkts = self.send_adv_payloads(STAGE_CONFIGS[CORRELATION_STAGE][0], STAGE_CONFIGS[CORRELATION_STAGE][1])
-                # Process sniffed packets
-                self.process_sniffed_pkts(sent_pkts, sniffer)
-        return True
-    
-STAGES = [SanityStage, CorrelationStage]
-
-class DownlinkTest(GenericTest):
-    def __init__(self, **kwargs):        
-        self.test_tooltip = "Stages examining gateway advertisements by issuing advertisement actions (txPacket)"
-        self.__dict__.update(kwargs)
-        super().__init__(**self.__dict__, test_name=type(self).__name__)
-        self.pkt_gen = BrgPktGenerator()
-        self.pkt_gen.set_bridge_id(DEFAULT_BRG_ID)
-        self.use_retries = self.topic_suffix == '-test'
-        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/generic.py

@@ -1,238 +0,0 @@
-import datetime
-import os
-from typing import Literal
-import math
-
-from gw_certificate.common.debug import debug_print
-from gw_certificate.api_if.gw_capabilities import GWCapabilities
-from gw_certificate.interface.ble_simulator import BLESimulator
-from gw_certificate.interface.mqtt import MqttClient
-from gw_certificate.ag.ut_defines import TEST_PASSED, TEST_FAILED, TEST_INCONCLUSIVE, TEST_OPTIONAL, TEST_WARNING, TEST_INFO
-
-PASS_STATUS = {True: 'PASS', False: 'FAIL'}
-
-# Score values for pass/inconclusive/fail
-PERFECT_SCORE = 100
-PASS_MINIMUM = 80
-INCONCLUSIVE_MINIMUM = 70
-INIT_INCONCLUSIVE_MINIMUM = 40
-MINIMUM_SCORE = 0
-
-# Results indications for stages. Must always be synced with frontend. 
-# 'score' shows as pass/inconclusive/fail. 'info' shows as info/warning.
-SCORE_BASED = 'score'
-INFORMATIVE = 'info'
-OPTIONAL = 'optional'
-
-ERR_SUMMARY_DEFAULT = 'View the stage report for more info. '
-
-class PassCriteria():
-    def __init__(self):
-        pass
-        
-    @staticmethod
-    def to_string(pass_value:int) -> str:
-        if pass_value >= PASS_MINIMUM:
-            return 'Pass'
-        elif pass_value >= INCONCLUSIVE_MINIMUM:
-            return 'Inconclusive'
-        else:
-            return 'Fail'
-    
-    @staticmethod
-    def calc_for_stage_downlink(rsquared, slope, stage_name:str, pkts_received):
-        error_msg = ''
-        if 'Sanity' in stage_name:
-            if pkts_received > 0:
-                return PERFECT_SCORE, error_msg
-            else:
-                error_msg = 'No advertisements were received from the gateway.'
-                return MINIMUM_SCORE, error_msg
-        else:
-            if rsquared > 0.7 and slope > 0:
-                return PERFECT_SCORE, error_msg
-            elif rsquared > 0.5 and slope > 0:
-                error_msg = "The correlation between 'txMaxDuration' and the board advertisements is suboptimal."
-                return INCONCLUSIVE_MINIMUM, error_msg
-            else:
-                error_msg = "The correlation between 'txMaxDuration' and the board advertisements is weak."
-                return MINIMUM_SCORE, error_msg
-
-    @staticmethod
-    def calc_for_test(test, stage) -> int:
-        # Some stages shouldn't affect test score
-        if 'Geolocation' in stage.stage_name or 'info' in stage.result_indication:
-            return test.test_pass
-
-        if stage.score_inconclusive() and test.score_pass():
-            return test.inconclusive_min
-        elif stage.score_fail():
-            return MINIMUM_SCORE
-        else:
-            return test.test_pass
-
-
-class GenericTest:
-    def __init__(self, mqttc: MqttClient, 
-                 gw_capabilities:GWCapabilities, gw_id, owner_id, test_name, ble_sim: BLESimulator = None, **kwargs):
-        # Clients
-        self.mqttc = mqttc
-        self.ble_sim = ble_sim
-        
-        # Test-Related
-        self.gw_capabilities = gw_capabilities
-        self.report = ''
-        self.report_html = ''
-        self.test_pass = PERFECT_SCORE
-        self.pass_min = PASS_MINIMUM
-        self.inconclusive_min = INCONCLUSIVE_MINIMUM
-        self.start_time = None
-        self.duration = None
-        self.test_name = test_name
-        self.test_dir = os.path.join(self.certificate_dir, self.test_name)
-        self.env_dirs.create_dir(self.test_dir)
-        self.stages = []
-        self.test_tooltip = kwargs.get('test_tooltip', 'Missing tooltip')
-        self.result_indication = kwargs.get('result_indication', SCORE_BASED)
-        self.rc = TEST_PASSED
-        
-    def __repr__(self):
-        return self.test_name
-    
-    def prepare_test(self):
-        pass
-    
-    def run(self):
-        self.start_time = datetime.datetime.now()
-        debug_print(f"Starting Test {self.test_name} : {self.start_time}")
-        
-    def runtime(self):
-        return datetime.datetime.now() - self.start_time
-    
-    def add_to_test_report(self, report):
-        self.report += '\n' + report
-    
-    def create_test_html(self):
-        self.report_html = self.template_engine.render_template('test.html', test=self,
-                                                                running_time = self.runtime())
-
-    def end_test(self):
-        self.determine_rc()
-        for stage in self.stages:
-            stage.determine_rc()
-        self.duration = self.runtime()
-        self.create_test_html()
-
-    def score_pass(self):
-        if self.test_pass >= self.pass_min:
-            return True
-        return False
-
-    def score_inconclusive(self):
-        if self.inconclusive_min <= self.test_pass < self.pass_min:
-            return True
-        return False
-    
-    def score_fail(self):
-        if self.test_pass < self.inconclusive_min:
-            return True
-        return False
-    
-    def determine_rc(self):
-        # Set test rc - defaults to TEST_PASSED (rc=0)
-        if self.result_indication == 'info':
-            if self.score_pass():
-                self.rc = TEST_INFO
-            else:
-                self.rc = TEST_WARNING
-        elif self.result_indication == 'optional':
-            self.rc = TEST_OPTIONAL
-        else:
-            if self.score_inconclusive():
-                self.rc = TEST_INCONCLUSIVE
-            elif self.score_fail():
-                self.rc = TEST_FAILED
-
-
-class GenericStage():
-    def __init__(self, stage_name, **kwargs):
-        #Stage Params
-        self.stage_name = stage_name
-        self.result_indication = kwargs.get('result_indication', SCORE_BASED)
-        self.stage_pass = MINIMUM_SCORE
-        self.pass_min = kwargs.get('pass_min', PASS_MINIMUM)
-        self.inconclusive_min = kwargs.get('inconclusive_min', INCONCLUSIVE_MINIMUM)
-        self.report = ''
-        self.report_html = ''
-        self.start_time = None
-        self.duration = None
-        self.csv_path = os.path.join(self.test_dir, f'{self.stage_name}.csv')
-        self.stage_tooltip = kwargs.get('stage_tooltip', 'Missing tooltip')
-        self.error_summary = kwargs.get('error_summary', ERR_SUMMARY_DEFAULT)
-        self.rc = TEST_PASSED
-        
-    def __repr__(self):
-        return self.stage_name
-    
-    def prepare_stage(self):
-        debug_print(f'### Starting Stage: {self.stage_name}')
-
-    def run(self):
-        self.start_time = datetime.datetime.now()
-
-    def add_to_stage_report(self, report):
-        self.report += f'{report}\n'
-    
-    def generate_stage_report(self):
-        return self.report
-    
-    def add_report_line_separator(self):
-        self.add_to_stage_report('-' * 50)
-    
-    def add_report_header(self):
-        uncapitalize = lambda s: s[:1].lower() + s[1:] if s else ''
-        self.duration = datetime.datetime.now() - self.start_time
-        self.add_to_stage_report(f'Stage run time: {self.duration}')
-        self.add_to_stage_report(f'This stage {uncapitalize(self.stage_tooltip)}.')
-        self.add_report_line_separator()
-    
-    def add_report_topic_validation(self, topic:Literal['status', 'data']):
-        pass
-        # Pass until validated
-        if self.topic_suffix != '':
-            return
-        valid_topic, invalid_msg, invalid_topic = self.mqttc.validate_serialization_topic(topic)
-        if valid_topic == False:
-            # For now not failing stage since the customBroker command include topics explicitly
-            # self.stage_pass = MINIMUM_SCORE
-            # self.error_summary += "Invalid serialization-topic combination. "
-            self.add_to_stage_report(f'Note: Received message on {invalid_topic} although serialization is {self.mqttc.get_serialization()}')
-            self.add_report_line_separator()
-    
-    def score_pass(self):
-        if self.stage_pass >= self.pass_min:
-            return True
-        return False
-
-    def score_inconclusive(self):
-        if self.inconclusive_min <= self.stage_pass < self.pass_min:
-            return True
-        return False
-    
-    def score_fail(self):
-        if self.stage_pass < self.inconclusive_min:
-            return True
-        return False
-            
-    def determine_rc(self):
-        # Set stage rc - defaults to TEST_PASSED (rc=0)
-        if self.result_indication == 'info':
-            if self.score_pass():
-                self.rc = TEST_INFO
-            else:
-                self.rc = TEST_WARNING
-        else:
-            if self.score_inconclusive():
-                self.rc = TEST_INCONCLUSIVE
-            elif self.score_fail():
-                self.rc = TEST_FAILED