wiliot-certificate 1.3.0a1__py3-none-any.whl → 1.4.0a1__py3-none-any.whl

gw_certificate/tests/actions.py

@@ -3,10 +3,17 @@ 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
+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):
@@ -41,13 +48,21 @@ class GatewayInfoStage(GenericActionsStage):
     
     def run(self):
         super().run()
-        self.gw_info = self.mqttc.get_gw_info()
+        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 not self.gw_info or "gatewayInfo" not in self.gw_info.body or len(self.gw_info.body) > 1:
+        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}')
@@ -81,6 +96,7 @@ class RebootStage(GenericActionsStage):
         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()
@@ -90,9 +106,7 @@ class RebootStage(GenericActionsStage):
         super().generate_stage_report()
 
         # Calculate whether stage pass/failed
-        if (self.status_message is None or 
-            (not any('gatewayconf' == key.lower() for key in self.status_message.keys()) and
-             not any('gatewaystatus' == key.lower() for key in self.status_message.keys()))):
+        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.")
@@ -110,8 +124,113 @@ class RebootStage(GenericActionsStage):
                                                                 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 = "The target bridge was not upgraded"
+        self.action = "Bridge Upgrade"
+
+        OTA_VERSIONS_TO_USE = ("4.4.52", "4.4.53")
+        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 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.uart.reset_gw(stop_advertising=False)
+                self.reboot_packet_ts = datetime.datetime.now()
+                debug_print("A reboot packet was received by the bridge")
+            self.action_status = self.mqttc.get_action_status_message()
+            time.sleep(2)
+        
+        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)
 
-STAGES = [GatewayInfoStage, RebootStage]
+        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()
+            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:
+            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:
+                self.add_to_stage_report(f"Note that the bridge was actually upgraded successfully.")
+            self.add_to_stage_report(f"{GW_BRIDGE_OTA_DOC}")
+        else:
+            if self.current_version == self.desired_version:
+                self.stage_pass = PERFECT_SCORE
+                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
+                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):        
@@ -119,7 +238,13 @@ class ActionsTest(GenericTest):
         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
-        self.stages = [stage(**self.__dict__) for stage in STAGES]
+        # 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()
@@ -128,4 +253,4 @@ class ActionsTest(GenericTest):
             stage.prepare_stage()
             stage.run()
             self.add_to_test_report(stage.generate_stage_report())
-            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)

gw_certificate/tests/connection.py

@@ -12,7 +12,9 @@ from gw_certificate.tests.generic import INCONCLUSIVE_MINIMUM, PassCriteria, MIN
 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):
@@ -28,8 +30,8 @@ class ConnectionStage(GenericStage):
                 '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('Waiting for GW to connect... (Timeout 3 minutes)')
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=3)
+        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:
@@ -67,6 +69,9 @@ class ConnectionStage(GenericStage):
                 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 = "No message recieved from GW in status topic after 3 mins."
             self.add_to_stage_report(self.error_summary)
@@ -167,15 +172,15 @@ class ConnectionTest(GenericTest):
         self.__dict__.update(kwargs)
         super().__init__(**self.__dict__, test_name=type(self).__name__)
         stages = STAGES
-        if version.parse(self.uart.get_version()) >= version.parse(INTERFERENCE_ANALYSIS_FW_VER):
+        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()
-        self.test_pass = PERFECT_SCORE
         for stage in self.stages:
             stage.prepare_stage()
             stage.run()
-            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)
             self.add_to_test_report(stage.generate_stage_report())

gw_certificate/tests/downlink.py

@@ -4,7 +4,6 @@ import json
 import os
 import time
 import pandas as pd
-import numpy as np
 import plotly.express as px
 from google.protobuf.json_format import MessageToDict
 
@@ -99,7 +98,7 @@ class GenericDownlinkStage(GenericStage):
                 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")
+            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)
@@ -166,9 +165,8 @@ class DownlinkTest(GenericTest):
     
     def run(self):
         super().run()
-        self.test_pass = PERFECT_SCORE
         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.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)

gw_certificate/tests/generic.py

@@ -1,11 +1,11 @@
 import datetime
 import os
+from typing import Literal
+import math
 
-from gw_certificate.api.extended_api import ExtendedEdgeClient
 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.if_defines import SEP
 from gw_certificate.interface.mqtt import MqttClient
 
 PASS_STATUS = {True: 'PASS', False: 'FAIL'}
@@ -23,6 +23,8 @@ SCORE_BASED = 'score'
 INFORMATIVE = 'info'
 OPTIONAL = 'optional'
 
+ERR_SUMMARY_DEFAULT = 'View the stage report for more info. '
+
 class PassCriteria():
     def __init__(self):
         pass
@@ -53,7 +55,7 @@ class PassCriteria():
     def calc_for_stage_downlink(rsquared, slope, stage_name:str):
         error_msg = ''
         if 'Sanity' in stage_name:
-            if rsquared > 0:
+            if not math.isnan(rsquared) and rsquared != 0:
                 return PERFECT_SCORE, error_msg
             else:
                 error_msg = 'No advertisements were received from the gateway.'
@@ -69,14 +71,17 @@ class PassCriteria():
                 return MINIMUM_SCORE, error_msg
 
     @staticmethod
-    def calc_for_test(test_pass_value:int, stage) -> int:
-        if stage.stage_pass < test_pass_value:
-            if 'Geolocation' in stage.stage_name or 'info' in stage.result_indication:
-                return test_pass_value
-            else:
-                return stage.stage_pass
+    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_pass_value
+            return test.test_pass
 
 
 class GenericTest:
@@ -90,7 +95,7 @@ class GenericTest:
         self.gw_capabilities = gw_capabilities
         self.report = ''
         self.report_html = ''
-        self.test_pass = MINIMUM_SCORE
+        self.test_pass = PERFECT_SCORE
         self.pass_min = PASS_MINIMUM
         self.inconclusive_min = INCONCLUSIVE_MINIMUM
         self.start_time = None
@@ -104,6 +109,9 @@ class GenericTest:
     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}")
@@ -121,6 +129,22 @@ class GenericTest:
     def end_test(self):
         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
+
+
 class GenericStage():
     def __init__(self, stage_name, **kwargs):
         #Stage Params
@@ -134,7 +158,7 @@ class GenericStage():
         self.start_time = 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', 'View the stage report for more info')
+        self.error_summary = kwargs.get('error_summary', ERR_SUMMARY_DEFAULT)
         
     def __repr__(self):
         return self.stage_name
@@ -159,3 +183,29 @@ class GenericStage():
         self.add_to_stage_report(f'Stage run time: {datetime.datetime.now() - self.start_time}')
         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']):
+        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'Warning: Received message on {invalid_topic} although serialization is {self.mqttc.get_serialization()}')
+    
+    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
+        

gw_certificate/tests/registration.py

@@ -2,6 +2,7 @@ import datetime
 import time
 import os
 from enum import Enum
+from typing import Literal
 
 from wiliot_api.api_client import WiliotCloudError
 
@@ -15,10 +16,13 @@ from gw_certificate.tests.static.references import GW_REGISTER_DOC, GW_MQTT_DOC
 # HELPER DEFINES
 REG_CERT_OWNER_ID = 'gw-certification-account'
 ENV_VAR_AWS = 'WLT_REG_CERT_KEY_AWS'
-STAGES_TIMEOUT = 2
+
+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_API_KEY = f'You must receive an API security key from wiliot and save if to the environment variable {ENV_VAR_AWS} first.'
 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.'
@@ -33,13 +37,10 @@ class GetGwField(Enum):
 
 class Status(Enum):
     PRE_REGISTERED = 'pre-registered'
+    REGISTERED = 'registered'
     APPROVED = 'approved'
     ACTIVE = 'active'
 
-class Online(Enum):
-    FALSE = False
-    TRUE = True
-
 class SharedData():
     """
     Hold variables which values must be shared between different stages.
@@ -59,7 +60,43 @@ class GenericRegistrationStage(GenericStage):
     def get_gateway_field(self, field:GetGwField):
         temp = self.edge.get_gateway(self.gw_id)
         return temp[field.value]
-
+    
+    def kick_gw_from_mqtt(self):
+        response = self.edge.kick_gw_from_mqtt(self.gw_id)
+        debug_print(f"Kick response:{response}")
+    
+    def validate_kong_logs(self, endpoint:Literal['device-authorize', 'registry', 'token', 'refresh']):
+        try:
+            message = self.edge.get_kong_logs(self.gw_id)
+        except WiliotCloudError as wce:
+            wce_dict = wce.args[0]
+            status_code = wce_dict.get('status_code')
+            msg = wce_dict.get('message')
+            if status_code == 404 and 'not found' in msg:
+                debug_print("Could not find gw when requesting for logs.")
+                debug_print("Either it is not registered, didn't issue any requests, or is missing the X-Gateway-ID header.")
+                return False
+            elif status_code == None:
+                raise wce
+        if message.get('status_code') != 200:
+            debug_print(f"Failed fetching logs, status_code:{message.get('status_code')}")
+            return False
+
+        # Convert 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:
+                    debug_print(f"An HTTP request to /{endpoint} resulted in an invalid response code:{response_code}")
+                else:
+                    debug_print(f"A valid HTTP request to /{endpoint} was received")
+                    return True
+        
+        debug_print(f"No valid HTTP request to /{endpoint} was found")
+        return False
+        
 class RegistryStage(GenericRegistrationStage):
     def __init__(self, **kwargs):
         self.__dict__.update(kwargs)
@@ -80,9 +117,13 @@ class RegistryStage(GenericRegistrationStage):
                 msg = wce_dict.get('message')
                 if status_code == 400 and 'already exists' in msg:
                     debug_print(f'{gw_id} already exists in Wiliot platform! Deleting and pre-registering from scratch')
+                    self.kick_gw_from_mqtt()
                     self.edge.delete_gateway(gw_id)
+                    time.sleep(CLOUD_DELAY_SEC)
                     pre_registered = self.edge.register_gateway([gw_id])
                 else:
+                    if status_code == 403:
+                        debug_print(f"The API key within {self.env_variable} seems invalid. It is not authorized to pre-register the gateway")
                     raise wce
             return pre_registered
 
@@ -96,12 +137,16 @@ class RegistryStage(GenericRegistrationStage):
     def run(self):
         super().run()
         debug_print(f"Waiting for the gateway to finish the Registry step..")
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        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(5)
+            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')
+
     def generate_stage_report(self):
         self.add_report_header()
         if not any(self.status == s.value for s in {Status.APPROVED, Status.ACTIVE}):
@@ -111,7 +156,8 @@ class RegistryStage(GenericRegistrationStage):
             debug_print(f"The gateway failed to register. Its status is '{self.status}' while it is expected to be '{Status.APPROVED.value}'.")
             self.add_to_stage_report(f"There was an error in the Device-authorize or Registry steps.")
             self.add_to_stage_report(f"Please go over the Device-authorize and Registry sections in this document:\n{GW_REGISTER_DOC}")
-            # TODO Ideally we should know where the error is exactly and inform the user. We currently lack such resolution
+            if self.status == Status.REGISTERED:
+                self.add_to_stage_report(f"Highly likely that the gateway is missing the 'X-Gateway-ID' header in it's HTTP requests.")
         else:
             self.stage_pass = PERFECT_SCORE
             self.add_to_stage_report("Device-authorize and Registry requests were issued well.")
@@ -134,12 +180,15 @@ class OnlineStage(GenericRegistrationStage):
     def run(self):
         super().run()
         debug_print(f"Waiting for the gateway to connect to MQTT..")
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        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 != True:
-            time.sleep(5)
+            time.sleep(BUSY_WAIT_DELAY_SEC)
             self.online = self.get_gateway_field(GetGwField.ONLINE)
 
+        time.sleep(CLOUD_DELAY_SEC)
+        self.validate_kong_logs('token')
+
     def generate_stage_report(self):
         self.add_report_header()
         if self.online != True:
@@ -149,8 +198,7 @@ class OnlineStage(GenericRegistrationStage):
             self.add_to_stage_report(f"Either it didn't acquire a token or it didn't connect to MQTT in time.")
             self.add_to_stage_report(f"Please go over the Poll For Token section in:\n{GW_REGISTER_DOC}")
             self.add_to_stage_report(f"and the MQTT details in:\n{GW_MQTT_DOC}")
-            debug_print("Gateway did not connect ot MQTT within time limit")
-            # TODO Ideally we should know where the error is exactly and inform the user. We currently lack such resolution
+            debug_print("Gateway did not connect to MQTT within time limit")
         else:
             self.stage_pass = PERFECT_SCORE
             self.add_to_stage_report("Token acquisition and MQTT connection were done succesfully.")
@@ -174,10 +222,10 @@ class ActiveStage(GenericRegistrationStage):
     def run(self):
         super().run()
         debug_print(f"Waiting for the gateway to upload a status message..")
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT_MINUTES)
         self.status = self.get_gateway_field(GetGwField.STATUS)
         while datetime.datetime.now() < timeout and self.status != Status.ACTIVE.value:
-            time.sleep(5)
+            time.sleep(BUSY_WAIT_DELAY_SEC)
             self.status = self.get_gateway_field(GetGwField.STATUS)
 
     def generate_stage_report(self):
@@ -212,22 +260,23 @@ class RefreshStage(GenericRegistrationStage):
         debug_print(f"Waiting for the token to expire..")
         timeout = self.shared_data.gw_online_ts + datetime.timedelta(minutes=TOKEN_EXPIRY_MINUTES)
         while datetime.datetime.now() < timeout:
-            time.sleep(5)
-
-        def kick_gw_from_mqtt():
-            response = self.edge.kick_gw_from_mqtt(self.gw_id)
-            debug_print(f"Kick response:{response}")
+            time.sleep(BUSY_WAIT_DELAY_SEC)
 
         debug_print(f"Token expired, kicking gateway")
-        kick_gw_from_mqtt()
+        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)
         debug_print(f"Waiting for the gateway to refresh its token and connect to MQTT..")
-        timeout = datetime.datetime.now() + datetime.timedelta(minutes=STAGES_TIMEOUT)
+        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 != True:
-            time.sleep(5)
+            time.sleep(BUSY_WAIT_DELAY_SEC)
             self.online = self.get_gateway_field(GetGwField.ONLINE)
 
+        time.sleep(CLOUD_DELAY_SEC)
+        self.validate_kong_logs('refresh')
+
     def generate_stage_report(self):
         self.add_report_header()
         if self.online != True:
@@ -257,9 +306,10 @@ class RegistrationTest(GenericTest):
 
         # Set up the edge client for all stages
         env = '' if self.env == 'prod' else '_' + str(self.env).upper()
-        api_sec_key = os.environ.get(ENV_VAR_AWS + env)
+        self.env_variable = ENV_VAR_AWS + env
+        api_sec_key = os.environ.get(self.env_variable)
         if not api_sec_key:
-            raise Exception(f"An API security key must be set to the envrionment variable {ENV_VAR_AWS} in order to run the RegistrationTest")
+            raise Exception(f"An API security key must be set to the envrionment variable {self.env_variable} in order to run the RegistrationTest")
         self.edge = ExtendedEdgeClient(api_sec_key, REG_CERT_OWNER_ID, env=self.env)
 
         self.shared_data = SharedData()
@@ -275,7 +325,7 @@ class RegistrationTest(GenericTest):
             stage.prepare_stage()
             stage.run()
             self.add_to_test_report(stage.generate_stage_report())
-            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)
+            self.test_pass = PassCriteria.calc_for_test(self, stage)
             if self.test_pass != PERFECT_SCORE and stage != self.stages[-1]:
                 debug_print(f"{type(self).__name__} stopped without running all of its stages since {type(stage).__name__} failed")
                 self.add_to_test_report(f"{type(self).__name__} stopped without running all of its stages since {type(stage).__name__} failed")
@@ -284,5 +334,6 @@ class RegistrationTest(GenericTest):
     
     def end_test(self):
         debug_print(f'Deleting {self.gw_id} from {REG_CERT_OWNER_ID} before exiting')
+        time.sleep(CLOUD_DELAY_SEC)
         self.edge.delete_gateway(self.gw_id)
         super().end_test()