wiliot-certificate 1.3.0a1__py3-none-any.whl

gw_certificate/interface/uart_if.py

@@ -0,0 +1,193 @@
+import datetime
+import subprocess
+import serial
+import serial.tools.list_ports
+import time
+import os.path
+import platform
+from packaging import version
+import pkg_resources
+
+from gw_certificate.common.debug import debug_print
+from gw_certificate.interface.if_defines import *
+
+LATEST_VERSION = '4.4.15'
+LATEST_VERSION_FILE = f'{LATEST_VERSION}_app.zip'
+LATEST_VERSION_PATH = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE)
+
+LATEST_VERSION_SNIFFING_KIT = '4.1.19'
+LATEST_VERSION_FILE_SNIFFING_KIT = f'{LATEST_VERSION_SNIFFING_KIT}_app.zip'
+LATEST_VERSION_PATH_SNIFFING_KIT = pkg_resources.resource_filename(__name__, LATEST_VERSION_FILE_SNIFFING_KIT)
+
+class UARTError(Exception):
+    pass
+
+class UARTInterface:
+    def __init__(self, comport, update_fw=True, sniffing_kit_flag=False):
+        self.comport = comport
+        self.serial = serial.Serial(port=comport, baudrate=921600, timeout=SERIAL_TIMEOUT)
+        self.serial.flushInput()
+        self.gw_app_rx = None
+        self.sniffing_kit_flag = sniffing_kit_flag
+        version_supported = self.check_fw_supported()
+        if not version_supported and update_fw:
+            update_status = self.update_firmware()
+            if not update_status:
+                raise UARTError('Update Failed! Update FW manually using NRF Tools')
+            if self.fw_version >= version.Version('3.17.0'):
+                self.write_ble_command(GATEWAY_APP)
+                self.flush()
+        debug_print(f'Serial Connection {comport} Initialized')
+
+    @staticmethod
+    def get_comports():
+        ports = serial.tools.list_ports.comports()
+        debug_print(SEP + "\nAvailable ports:")
+        for port, desc, hwid in sorted(ports):
+            debug_print("{}: {} [{}]".format(port, desc, hwid))
+        debug_print(SEP + "\n")
+        return ports
+
+    def read_line(self):
+        # This reads a line from the ble device (from the serial connection using ble_ser),
+        # strips it from white spaces and then decodes to string from bytes using the "utf-8" protocol.
+        answer = self.serial.readline().strip().decode("utf-8", "ignore")
+        if len(answer) == 0:
+            return None
+        return answer
+
+    def write_ble_command(self, cmd, read=False):
+        # This function writes a command (cmd) to the ble using a serial connection (ble_ser) that are provided to it beforehand.. and returns the answer from the device as string
+        debug_print("Write to BLE: {}".format(cmd))
+        # Shows on terminal what command is about to be printed to the BLE device
+        bytes_to_write = bytes(cmd.encode("utf-8")) + b'\r\n'
+        self.serial.write(bytes_to_write)
+        answer = None
+        if read:
+            # The "bytes" function converts the command from string to bytes by the specified "utf-8" protocol then we use .write to send the byte sequence to the ble device using the serial connection that we have for this port (ble_ser)
+            # Pauses the program for execution for 0.01sec. This is done to allow the device to process the command and provide a response before reading the response.
+            time.sleep(1)
+            answer = self.read_line()
+            debug_print(answer)
+        return answer
+    
+    def flush(self):
+        self.serial.close()
+        self.serial.open()
+        self.serial.flushInput()
+        self.serial.flush()
+        self.serial.reset_output_buffer()
+
+    def reset_gw(self):
+        self.flush()
+        self.write_ble_command(RESET_GW)
+        self.gw_app_rx = None
+        time.sleep(3)
+        self.write_ble_command(STOP_ADVERTISING)
+        time.sleep(3)
+
+
+    def cancel(self):
+        self.write_ble_command(CANCEL)
+
+    def set_rx(self, rx_channel):
+        if self.sniffing_kit_flag:
+            assert rx_channel in RX_CHANNELS_SNIFFING_KIT
+        else:
+            assert rx_channel in RX_CHANNELS
+        if self.gw_app_rx is None:
+            self.reset_gw()
+
+        if self.fw_version >= version.Version('3.17.0'):
+            # from 3.17.0, only full_cfg can be used to configure channels. sending it with:
+            # Data coupling(DC) off, wifi(NW) and mqtt(MQ) on.
+            rx_ch_to_fw_enums = {37: 2, 38: 3, 39: 4}
+            if self.sniffing_kit_flag:
+                my_dict = {i: 5 + i for i in range(37)}
+                rx_ch_to_fw_enums.update(my_dict)
+            cmd = f'!full_cfg DM {rx_ch_to_fw_enums[rx_channel]} DC 0 NW 1 MQ 1 CH {rx_channel}'
+            # cmd = '!gateway_app'
+        else:
+            cmd = f'!gateway_app {rx_channel} 30 0 17'
+
+        self.write_ble_command(cmd)
+        self.gw_app_rx = rx_channel
+
+    def set_sniffer(self, rx_channel):
+        self.set_rx(rx_channel)
+        self.flush()
+        time.sleep(1)
+        if self.fw_version >= version.Version('4.1.0'):
+            self.write_ble_command(f'{SET_SNIFFER} {rx_channel}')
+        else:
+            self.write_ble_command(SET_SNIFFER)
+        self.flush()
+        time.sleep(1)
+
+    def cancel_sniffer(self):
+        self.write_ble_command(CANCEL_SNIFFER)
+        self.flush()
+
+    def get_version(self):
+        self.reset_gw()
+        self.flush()
+        timeout = datetime.datetime.now() + datetime.timedelta(seconds=15)
+        while datetime.datetime.now() < timeout:
+            raw_version = self.write_ble_command(VERSION, read=True)
+            if raw_version is not None:
+                if GW_APP_VERSION_HEADER in raw_version:
+                    return raw_version.split(' ')[0].split('=')[1]
+        return None
+    
+    def check_fw_supported(self):
+        current_version = self.get_version()
+        if current_version is None:
+            raise UARTError("Cannot initialize board! Please try disconnecting and connecting USB cable")
+        current_version = version.parse(current_version)
+        hex_version = version.parse(os.path.splitext(os.path.basename(LATEST_VERSION_PATH))[0].split('_')[0])
+        self.fw_version = current_version
+        if current_version >= hex_version:
+            debug_print(f'GW Running version {current_version}')
+            self.fw_version = current_version
+            return True
+        return False
+
+    def update_firmware(self):
+        NRFUTIL_MAP = {"Linux": "nrfutil-linux", "Darwin": "nrfutil-mac", "Windows": "nrfutil.exe"}
+        nrfutil_file = pkg_resources.resource_filename(__name__, NRFUTIL_MAP[platform.system()])
+        # In order to support NRF UART FW update with protobuf > 3.20.0
+        os.environ['PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION'] = 'python'
+        
+        self.write_ble_command('!reset', read=True)
+        self.write_ble_command('!move_to_bootloader', read=True)
+        self.serial.close()
+        p = None
+        if self.sniffing_kit_flag:
+            p = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH_SNIFFING_KIT}" -p {self.comport} -fc 0 -b 115200 -t 10', shell=True)
+        else:
+            p = subprocess.Popen(f'{nrfutil_file} dfu serial --package "{LATEST_VERSION_PATH}" -p {self.comport} -fc 0 -b 115200 -t 10', shell=True)
+        p.wait()
+        return_code = p.returncode
+        debug_print('Waiting for device to update...')
+        timeout = datetime.datetime.now() + datetime.timedelta(minutes=2)
+        current_ver = ''
+        time.sleep(15)
+        self.serial.open()
+        self.flush()
+        while GW_APP_VERSION_HEADER not in current_ver and datetime.datetime.now() < timeout:
+            current_ver = self.write_ble_command(VERSION, read=True)
+            if current_ver is None:
+                current_ver = ''
+            time.sleep(1)
+        if self.sniffing_kit_flag:
+            if current_ver.split(' ')[0].split('=')[1] != LATEST_VERSION_SNIFFING_KIT:
+                return False
+        else:
+            if current_ver.split(' ')[0].split('=')[1] != LATEST_VERSION:
+                return False
+        if return_code == 0:
+            self.fw_version = version.parse(current_ver.split(' ')[0].split('=')[1])
+            return True
+        return False
+
+        ### TODO: Sequence List

gw_certificate/interface/uart_ports.py

@@ -0,0 +1,20 @@
+import sys
+import serial.tools.list_ports
+
+def get_uart_ports(silent=True):
+    ports = serial.tools.list_ports.comports()
+    uart_ports = []
+    if not silent:
+        sys.stdout.write('[')
+    for port, desc, hwid in sorted(ports):
+        if 'USB to UART' not in desc:
+            continue
+        if not silent:
+            sys.stdout.write(f'("{port}", "{desc}", "{hwid}"),') 
+        uart_ports.append(port)
+    if not silent: 
+        sys.stdout.write(']')
+    return uart_ports
+
+if __name__ == '__main__':
+    get_uart_ports(silent=False)

gw_certificate/templates/results.html

@@ -0,0 +1,241 @@
+<!doctype html>
+<html lang="en">
+    <head>
+        <!-- Required meta tags -->
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>{{ page_title }}</title>
+        <link rel="icon" href="https://www.wiliot.com/favicon.ico" type="image/x-icon" />
+        <!-- JQuery -->
+        <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+        <!-- Bootstrap CSS -->
+        <link href="https://cdn.jsdelivr.net/npm/bootstrap@latest/dist/css/bootstrap.min.css" rel="stylesheet">
+        <!-- DataTables -->
+        <link rel="stylesheet" href="https://cdn.datatables.net/1.13.7/css/jquery.dataTables.css" />
+        <script src="https://cdn.datatables.net/1.13.7/js/jquery.dataTables.js"></script>
+    
+        <style>
+            #card-body {
+                height: auto;
+                overflow:auto; 
+            }
+            .pass {
+                color: green;
+            }
+            .inconclusive {
+                color: rgb(160, 160, 2);
+            }
+            .fail {
+                color: red;
+            }
+
+        </style>
+        <title>{{ title }}</title>
+    </head>
+    <body>
+    <br>
+    <div class="text-center">
+        <img src="https://www.wiliot.com/src/img/svg/logo.svg" class="img-fluid" alt="">
+    </div>
+    <br>
+        <div class="container">
+            <h1> GW Certificate | version {{version}} | {{ gw_id }} | {{ datetime }}</h1>
+            <div class="card">
+                <div class="card-header">
+                    Tests Summary
+                </div>
+                <div class="card-body" id="card-body">
+                    <div class="test-list">
+                        {% for test in tests %}
+                        <div class="test">
+                            <span class="d-inline-block" tabindex="0" data-bs-toggle="tooltip" data-bs-placement="right" title="{{ test.test_tooltip }}">
+                                {% if test.result_indication == 'info' %}
+                                    <h5>{{ test.test_name }}: {% if test.test_pass >= test.pass_min %}<span class="badge bg-info text-dark">Info</span>{% else %}<span class="badge bg-warning text-dark">Warning</span>{% endif %}</h5>
+                                {% elif test.result_indication == 'optional' %}
+                                    <h5>{{ test.test_name }}: <span class="badge bg-secondary">Optional</span></h5>
+                                {% else %}
+                                    <h5>{{ test.test_name }}: {% if test.test_pass >= test.pass_min %}<span class="badge bg-success">Pass</span>{% elif test.test_pass >= test.inconclusive_min %}<span class="badge bg-warning text-dark">Inconclusive</span>{% else %}<span class="badge bg-danger">Fail</span>{% endif %}</h5>
+                                {% endif %}
+                            </span>
+                            <br>
+                                {% for stage in test.stages %}
+                                    <span class="d-inline-block" tabindex="0" data-bs-toggle="tooltip" data-bs-placement="right" title="{{ stage.stage_tooltip }}" >
+                                        {% if stage.result_indication == 'info' %}
+                                            <h6> - {{ stage.stage_name }}: {% if stage.stage_pass >= stage.pass_min %}<span class="badge bg-info text-dark">Info</span>{% else %}<span class="badge bg-warning text-dark">Warning</span>{% endif %} </h6> 
+                                        {% else %}
+                                            <h6> - {{ stage.stage_name }}: {% if stage.stage_pass >= stage.pass_min %}<span class="badge bg-success">Pass</span>{% elif stage.stage_pass >= stage.inconclusive_min %}<span class="badge bg-warning text-dark">Inconclusive</span>{% else %}<span class="badge bg-danger">Fail</span>{% endif %} </h6>
+                                        {% endif %}
+                                    </span>
+                                    <br>
+                                {% endfor %}
+                        </div>
+                        {% endfor %}
+                    </div>
+                    <i> <sub>Hover over each line for a brief explainer </sub> </i>
+                </div>
+            </div>
+        </div>
+    <br>
+    <div class="container">
+    {% for test in tests %}
+    <div class="accordion" id="accordion{{ loop.index }}">
+        <div class="accordion-item">
+            <h2 class="accordion-header" id="heading{{ loop.index }}">
+                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#collapse{{ loop.index }}" aria-expanded="false" aria-controls="collapse{{ loop.index }}">
+                    {% if test.result_indication == 'info' %}
+                        {{ test.test_name }}:&nbsp; {% if test.test_pass >= test.pass_min %}<span class="badge bg-info text-dark">Info</span>{% else %}<span class="badge bg-warning text-dark">Warning</span>{% endif %}
+                    {% elif test.result_indication == 'optional' %}
+                        {{ test.test_name }}:&nbsp; <span class="badge bg-secondary">Optional</span>
+                    {% else %}
+                        {{ test.test_name }}:&nbsp; {% if test.test_pass >= test.pass_min %}<span class="badge bg-success">Pass</span>{% elif test.test_pass >= test.inconclusive_min %}<span class="badge bg-warning text-dark">Inconclusive</span>{% else %}<span class="badge bg-danger">Fail</span>{% endif %}
+                    {% endif %}
+                </button>
+            </h2>
+            <div id="collapse{{ loop.index }}" class="accordion-collapse collapse" aria-labelledby="heading{{ loop.index }}" data-bs-parent="#accordion{{ loop.index }}">
+                <div class="accordion-body">
+                    {{ test.report_html }}
+                </div>
+            </div>
+        </div>
+    </div>
+    {% endfor %}
+    <div class="accordion" id="accordion_log">
+            <div class="accordion-item">
+                <h2 class="accordion-header" id="heading_log">
+                    <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#collapse_log" aria-expanded="false" aria-controls="collapse_log">
+                        GW Certificate Log
+                    </button>
+                </h2>
+                <div id="collapse_log" class="accordion-collapse collapse" aria-labelledby="heading_log" data-bs-parent="#accordion_log">
+                    <div class="accordion-body">
+                        <div class="container">
+                            <div class="card">
+                                <div class="card-header">
+                                    GW Certificate Log
+                                </div>
+                                <div class="card-body" id="card-body" style="height: 500px; overflow: auto">
+                                    <samp>
+                                        {% for line in log %}
+                                        {{ line | safe}}<br />
+                                        {% endfor %}
+                                    </samp>
+                                </div>
+                            </div>
+                        </div>
+                        <br>
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div class="accordion" id="accordion_mqtt_log">
+            <div class="accordion-item">
+                <h2 class="accordion-header" id="heading_mqtt_log">
+                    <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#collapse_mqtt_log" aria-expanded="false" aria-controls="collapse_mqtt_log">
+                        MQTT Log
+                    </button>
+                </h2>
+                <div id="collapse_mqtt_log" class="accordion-collapse collapse" aria-labelledby="heading_mqtt_log" data-bs-parent="#accordion_log">
+                    <div class="accordion-body">
+                        <div class="container">
+                            <div class="card">
+                                <div class="card-header">
+                                    MQTT Log
+                                </div>
+                                <div class="card-body" id="card-body" style="height: 500px; overflow: auto">
+                                    <samp>
+                                        {% for line in mqtt_log %}
+                                        {{ line | safe}}<br />
+                                        {% endfor %}
+                                    </samp>
+                                </div>
+                            </div>
+                        </div>
+                        <br>
+                    </div>
+                </div>
+            </div>
+        </div>
+    <div class="accordion" id="accordion_sniffer_log">
+        <div class="accordion-item">
+            <h2 class="accordion-header" id="heading_sniffer_log">
+                <button class="accordion-button collapsed" type="button" data-bs-toggle="collapse" data-bs-target="#collapse_sniffer_log" aria-expanded="false" aria-controls="collapse_sniffer_log">
+                    Sniffer Log
+                </button>
+            </h2>
+            <div id="collapse_sniffer_log" class="accordion-collapse collapse" aria-labelledby="heading_sniffer_log" data-bs-parent="#accordion_log">
+                <div class="accordion-body">
+                    <div class="container">
+                        <div class="card">
+                            <div class="card-header">
+                                Sniffer Log
+                            </div>
+                            <div class="card-body" id="card-body" style="height: 500px; overflow: auto">
+                                <samp>
+                                    {% for line in sniffer_log %}
+                                    {{ line | safe}}<br />
+                                    {% endfor %}
+                                </samp>
+                            </div>
+                        </div>
+                    </div>
+                    <br>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- <br>
+    <div class="text-center">
+        <br>
+        <h6>Certified Partners</h6>
+    </div>
+    <div id="certifiedPartnersCarousel" class="carousel slide" data-bs-ride="carousel" data-bs-pause="false" data-bs-interval="10000">
+        <div class="carousel-inner">
+            <div class="carousel-item active">
+                <div class="row d-flex flex-wrap align-items-center" style="height: 50px;">
+                    <img src="https://www.wiliot.com/src/uploads/_partnersListingLogo/Screenshot-2024-07-08-at-9.36.37-AM.png" class="d-block mx-auto" style="width: 120px;" alt="Image missing">
+                </div>
+            </div>
+            <div class="carousel-item">
+                <div class="row d-flex flex-wrap align-items-center" style="height: 50px;">
+                    <img src="https://www.wiliot.com/src/uploads/_partnersListingLogo/rigado.png" class="d-block mx-auto" style="width: 120px;" alt="Image missing">
+                </div>
+            </div>
+            <div class="carousel-item">
+                <div class="row d-flex flex-wrap align-items-center" style="height: 50px;">
+                    <img src="https://www.minew.com/wp-content/uploads/2024/06/mine-logo-black.png" class="d-block mx-auto" style="width: 120px;" alt="Image missing">
+                </div>
+            </div>
+        </div>
+    </div>
+    <br> -->
+
+<!-- Accordion listener to adjust table -->
+<script defer type="text/javascript">
+    var accordions = document.getElementsByClassName('accordion')
+    Array.prototype.forEach.call(accordions, (el) => {
+        el.addEventListener('shown.bs.collapse', function () {
+            DataTable.tables({ visible: true, api: true }).columns.adjust();
+        });
+    });
+    </script>
+
+
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js"
+        integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM"
+        crossorigin="anonymous"></script>
+<script>
+        var tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'))
+        var tooltipList = tooltipTriggerList.map(function (tooltipTriggerEl) {
+        return new bootstrap.Tooltip(tooltipTriggerEl)
+        })
+    </script>
+    <style>
+        .tooltip-inner {
+            max-width: 1000px;
+            /* width: 570px; */
+            font-size:larger;
+        }
+    </style>
+</body>
+</html>

gw_certificate/templates/stage.html

@@ -0,0 +1,22 @@
+<div class="card">
+    <div class="card-header" id="{{ stage.stage_name }}">
+        {% if stage.result_indication == 'info' %}
+            {{ stage.stage_name }}: {% if stage.stage_pass >= stage.pass_min %}<span class="badge bg-info text-dark">Info</span>{% else %}<span class="badge bg-warning text-dark">Warning</span>{% endif %}
+        {% else %}
+            {{ stage.stage_name }}: {% if stage.stage_pass >= stage.pass_min %}<span class="badge bg-success">Pass</span>{% elif stage.stage_pass >= stage.inconclusive_min %}<span class="badge bg-warning text-dark">Inconclusive</span>{% else %}<span class="badge bg-danger">Fail</span>{% endif %}
+        {% endif %}
+
+    </div>
+    <div class="card-body" id="card-body">
+        <samp>
+            {% for line in stage_report %}
+            {{ line | safe}}<br />
+            {% endfor %}
+        </samp>
+    </div>
+    <!-- Insert table here if available-->
+    {{ table|safe }}
+    <!-- Insert graph here if available-->
+    {{ graph|safe }}
+</div>
+<br>

gw_certificate/templates/table.html

@@ -0,0 +1,6 @@
+{{ dataframe }}
+
+{% set let_line = 'let ' + table_id + ' = new DataTable("#' + table_id + '", {scrollY: "300px", scrollX: true});' %}
+<script defer type="text/javascript">
+    {{ let_line }}
+</script>

gw_certificate/templates/test.html

@@ -0,0 +1,38 @@
+<div class="container">
+    {% if test.result_indication == 'info' %}
+        <h3>{{ test.test_name }}: {% if test.test_pass >= test.pass_min %}<span class="badge bg-info text-dark">Info</span>{% else %}<span class="badge bg-warning text-dark">Warning</span>{% endif %}</h3>
+    {% elif test.result_indication == 'optional' %}
+        <h3>{{ test.test_name }}: <span class="badge bg-secondary">Optional</span></h3>
+    {% else %}
+        <h3>{{ test.test_name }}: {% if test.test_pass >= test.pass_min %}<span class="badge bg-success">Pass</span>{% elif test.test_pass >= test.inconclusive_min %}<span class="badge bg-warning text-dark">Inconclusive</span>{% else %}<span class="badge bg-danger">Fail</span>{% endif %}</h3>
+    {% endif %}
+    <h4>Running Time: {{ running_time }}</h4>
+
+    {% if test.test_pass < test.pass_min %}
+        <h5>Error summary:</h5>
+        {% for stage in test.stages %}
+            {% if stage.result_indication == 'info' %}
+                {% if stage.stage_pass < stage.pass_min %}
+                    <div class="alert alert-warning" role="alert">
+                        <a href="#{{ stage.stage_name }}" class="alert-link">{{ stage.stage_name }}</a>: {{ stage.error_summary }}
+                    </div>
+                {% endif %}
+            {% else %}
+                {% if stage.stage_pass < stage.inconclusive_min %}
+                    <div class="alert alert-danger" role="alert">
+                        <a href="#{{ stage.stage_name }}" class="alert-link">{{ stage.stage_name }}</a>: {{ stage.error_summary }}
+                    </div>
+                {% elif stage.stage_pass < stage.pass_min %}
+                    <div class="alert alert-warning" role="alert">
+                        <a href="#{{ stage.stage_name }}" class="alert-link">{{ stage.stage_name }}</a>: {{ stage.error_summary }}
+                    </div>
+                {% endif %}
+            {% endif %}
+        {% endfor %}
+    {% endif %}
+    <hr>
+    {% for stage in test.stages %}
+        {{ stage.report_html }}
+    {% endfor %}
+</div>
+<br>

gw_certificate/tests/__init__.py

@@ -0,0 +1,11 @@
+from gw_certificate.tests.registration import RegistrationTest
+from gw_certificate.tests.connection import ConnectionTest
+from gw_certificate.tests.uplink import UplinkTest
+from gw_certificate.tests.downlink import DownlinkTest 
+from gw_certificate.tests.actions import ActionsTest
+from gw_certificate.tests.throughput import StressTest
+
+TESTS = [RegistrationTest, ConnectionTest, UplinkTest, DownlinkTest, ActionsTest, StressTest]
+
+TESTS_DEFAULT = [ConnectionTest, UplinkTest, DownlinkTest, ActionsTest, StressTest]
+TESTS_NO_UART = [RegistrationTest, ActionsTest]

gw_certificate/tests/actions.py

@@ -0,0 +1,131 @@
+import datetime
+import os
+import time
+import pandas as pd
+
+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
+
+
+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()
+        self.gw_info = self.mqttc.get_gw_info()
+
+    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:
+            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
+
+        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 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()))):
+            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
+
+
+STAGES = [GatewayInfoStage, RebootStage]
+
+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
+        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.add_to_test_report(stage.generate_stage_report())
+            self.test_pass = PassCriteria.calc_for_test(self.test_pass, stage)