testexecutor-ui 0.6.1__py3-none-any.whl

testexecutor/model/MultiTestWindowModel.py

@@ -0,0 +1,184 @@
+#  Copyright 2020 Direkt, Australia
+#  Copyright 2021 Direkt Embedded Pty Ltd
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from PySide6.QtCore import QObject, QJsonDocument
+from PySide6.QtCore import Signal, Property, Slot
+from PySide6.QtWidgets import QApplication
+from PySide6.QtCore import QUrl
+from PySide6.QtCore import Qt
+from PySide6.QtCore import QCoreApplication
+from PySide6.QtGui import QIcon
+from PySide6.QtQml import QQmlApplicationEngine
+
+import os
+import sys
+import json
+
+notice = """
+<b>This software includes code from Test Executor ™</b><br/>
+<i>Copyright © Direkt Embedded Pty Ltd<br/>
+https://www.direktembedded.com</i>"""
+
+class MultiTestWindowModel(QObject):
+
+    def __init__(self, suiteGroup=None, title="Test Executor", closeHeading="There Are Still Tests Running", closeText="Stop all suites if you want to quit"):
+        QObject.__init__(self)
+        self._title = title
+        self._visibility = "Maximized"
+        self._abortCallback = None
+        self._closeHeading = closeHeading
+        self._closeText = closeText
+        self._allowAbort = False
+        self._config = None
+        self._suiteGroup = suiteGroup
+        self._about = None
+        if suiteGroup is not None and suiteGroup.abortAll is not None:
+            self._abortCallback = suiteGroup.abortAll
+            self._allowAbort = True
+            self._closeText = "Do you want to abort all tests?"
+
+    def _settitle(self, title):
+        """ Setter for title Property """
+        if self._title != title:
+            self._title = title
+            self.title_changed.emit()
+
+    def _gettitle(self):
+        """ Getter for title Property """
+        return self._title
+
+    title_changed = Signal()
+    title = Property(str, _gettitle, _settitle, notify=title_changed)
+
+    def _setvisibility(self, visibility):
+        """ Setter for visibility Property """
+        if self._visibility != visibility:
+            self._visibility = visibility
+            self.visibility_changed.emit()
+
+    def _getvisibility(self):
+        """ Getter for visibility Property """
+        return self._visibility
+
+    visibility_changed = Signal()
+    visibility = Property(str, _getvisibility, _setvisibility, notify=visibility_changed)
+
+    def _setabout(self, about):
+        """ Setter for about Property. Expects html (or rich text subset there of) """
+        if self._about != about:
+            self._about = about
+            self.about_changed.emit()
+
+    def _getabout(self):
+        """ Getter for about Property """
+        return self._add_notice(self._about)
+
+    def _add_notice(self, about):
+        if about:
+            about = f"{about}<br/>{notice}"
+        else:
+            about = notice
+        return about
+
+    about_changed = Signal()
+    about = Property(str, _getabout, _setabout, notify=about_changed)
+
+    def _setcloseHeading(self, closeHeading):
+        """ Setter for closeHeading Property """
+        if self._closeHeading != closeHeading:
+            self._closeHeading = closeHeading
+            self.closeHeading_changed.emit()
+
+    def _getcloseHeading(self):
+        """ Getter for closeHeading Property """
+        return self._closeHeading
+
+    closeHeading_changed = Signal()
+    closeHeading = Property(str, _getcloseHeading, _setcloseHeading, notify=closeHeading_changed)
+
+    def _setcloseText(self, closeText):
+        """ Setter for closeText Property """
+        if self._closeText != closeText:
+            self._closeText = closeText
+            self.closeText_changed.emit()
+
+    def _getcloseText(self):
+        """ Getter for closeText Property """
+        return self._closeText
+
+    closeText_changed = Signal()
+    closeText = Property(str, _getcloseText, _setcloseText, notify=closeText_changed)
+
+    def _setallowAbort(self, allowAbort):
+        """ Setter for allowAbort Property """
+        if self._allowAbort != allowAbort:
+            self._allowAbort = allowAbort
+            self.allowAbort_changed.emit()
+
+    def _getallowAbort(self):
+        """ Getter for allowAbort Property """
+        return self._allowAbort
+
+    allowAbort_changed = Signal()
+    allowAbort = Property(bool, _getallowAbort, _setallowAbort, notify=allowAbort_changed)
+
+    def _setconfig(self, config):
+        """ Setter for config Property """
+        if self._config != config:
+            self._config = config
+            self.config_changed.emit()
+
+    def _getconfig(self):
+        """ Getter for config Property """
+        return self._config
+
+    config_changed = Signal()
+    config = Property(str, _getconfig, _setconfig, notify=config_changed)
+
+
+    @Slot(bool)
+    def abortAll(self, hard=False):
+        if self._abortCallback:
+            self._abortCallback(hard)
+
+    def exec(self, iconFile=None):
+        current_path = os.path.dirname(os.path.abspath(__file__))
+        relative_path = os.path.join(current_path, "..")
+        ui_path = os.path.join(relative_path, 'ui')
+        qml_file = os.path.join(ui_path, 'MultiTestWindow.qml')
+        url = QUrl.fromLocalFile(qml_file)
+        if not iconFile:
+            iconFile = os.path.join(ui_path, 'te-64x64.ico')
+
+        QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
+        QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
+        app = QApplication(sys.argv)
+
+        app.setWindowIcon(QIcon(iconFile))
+        if self.config:
+            check_json = json.loads(self.config)
+        engine = QQmlApplicationEngine()
+        engine.rootContext().setContextProperty("app_model", self)
+        if self.config:
+            engine.rootContext().setContextProperty("contextKeyValueItemConfig",
+                                                    json.dumps(check_json["identification"]["item"]))
+            if "controller" in check_json:
+                engine.rootContext().setContextProperty("contextFilterSelectorItemConfig",
+                                                    json.dumps(check_json["controller"]["filter"]["item"]))
+        engine.rootContext().setContextProperty("model_list", self._suiteGroup)
+
+        engine.load(url)
+
+        return app.exec_()

testexecutor/model/ResultModel.py

@@ -0,0 +1,314 @@
+#  Copyright 2020 Direkt, Australia
+#  Copyright 2021 Direkt Embedded Pty Ltd
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+# This Python file uses the following encoding: utf-8
+import threading
+from PySide6 import QtCore
+from PySide6.QtCore import QAbstractListModel
+from PySide6.QtCore import Qt
+from PySide6.QtCore import QModelIndex
+from PySide6.QtCore import Slot
+from PySide6.QtCore import Signal
+from PySide6.QtCore import Property
+from PySide6.QtCore import QObject
+
+class Result(QObject):
+
+    StateRunning = "Running"
+    StatePass = "Pass"
+    StateFail = "Fail"
+
+    def __init__(self, name, result=None, feedback=None):
+        QObject.__init__(self)
+        self.lock = threading.RLock()
+        self._name = name
+        self._feedback = feedback
+        self._result = result
+        self._duration = 0
+        self._progress = 0
+
+    def _setfeedback(self, feedback):
+        """ Setter for feedback Property """
+        changed = False
+        with self.lock:
+            if self._feedback != feedback:
+                self._feedback = feedback
+                changed = True
+        if changed:
+            self.feedback_changed.emit()
+
+    def _getfeedback(self):
+        """ Getter for feedback Property """
+        with self.lock:
+            fb = self._feedback
+        return fb
+
+    feedback_changed = Signal()
+    feedback = Property(str, _getfeedback, _setfeedback, notify=feedback_changed)
+
+    def _setresult(self, result):
+        """ Setter for result Property """
+        changed = False
+        with self.lock:
+            if self._result != result:
+                self._result = result
+                changed = True
+        if changed:
+            self.result_changed.emit()
+
+    def _getresult(self):
+        """ Getter for result Property """
+        with self.lock:
+            r = self._result
+        return r
+
+    result_changed = Signal()
+    result = Property(str, _getresult, _setresult, notify=result_changed)
+
+    def _setduration(self, duration):
+        """ Setter for duration Property """
+        changed = False
+        with self.lock:
+            if self._duration != duration:
+                self._duration = duration
+                changed = True
+        if changed:
+            self.duration_changed.emit()
+
+    def _getduration(self):
+        """ Getter for duration Property """
+        with self.lock:
+            dur = self._duration
+        return dur
+
+    duration_changed = Signal()
+    duration = Property(int, _getduration, _setduration, notify=duration_changed)
+
+    def _setname(self, name):
+        """ Setter for name Property """
+        changed = False
+        with self.lock:
+            if self._name != name:
+                self._name = name
+                changed = True
+        if changed:
+            self.name_changed.emit()
+
+    def _getname(self):
+        """ Getter for name Property """
+        with self.lock:
+            n = self._name
+        return n
+
+    name_changed = Signal()
+    name = Property(str, _getname, _setname, notify=name_changed)
+
+    def _setprogress(self, progress):
+        """ Setter for progress Property """
+        changed = False
+        with self.lock:
+            if self._progress != progress:
+                if progress > 1:
+                    progress = 1
+                elif progress < 0:
+                    progress = 0
+                self._progress = progress
+                changed = True
+        if changed:
+            self.progress_changed.emit()
+
+    def _getprogress(self):
+        """ Getter for progress Property """
+        return self._progress
+
+    progress_changed = Signal()
+    progress = Property(float, _getprogress, _setprogress, notify=progress_changed)
+
+
+class ResultModel(QAbstractListModel):
+
+    TestRole = Qt.UserRole
+    TestKey = b"test"
+
+    def __init__(self, parent=None):
+        QAbstractListModel.__init__(self, parent)
+        self.lock = threading.RLock()
+        self._currentTestIndex = -1
+        self._data = []
+
+    def rowCount(self, parent=QModelIndex()):
+        return len(self._data)
+
+    def roleNames(self):
+        return {self.TestRole: self.TestKey}
+
+    def data(self, index, role=None):
+        i = index.row()
+        if len(self._data) > i:
+            d = self._data[i]
+            if role == self.TestRole:
+                return d[self.TestKey]
+        return None
+
+    def setData(self, index, value, role=None):
+        i = index.row()
+        if len(self._data) > i:
+            self._data[index.row()] = value
+            self.dataChanged.emit(index, index, self.roleNames())
+
+    def overallResult(self):
+        """
+        Return the test suite result status
+        :return: None: State is unknown. Either no test results or error occurred.
+                 Result.StateRunning: A test is in progress
+                 Result.StatePass: All test have been run and all passed
+                 Result.StateFail: One state failed
+        """
+        overall_result = None
+        if self._data and len(self._data):
+            for item in self._data:
+                test = item[self.TestKey]
+                if test.result == Result.StateFail:
+                    overall_result = test.result
+                    break
+                elif test.result == Result.StateRunning:
+                    overall_result = test.result
+                    break
+            if not overall_result:
+                overall_result = Result.StatePass
+        return overall_result
+
+
+    @Slot(str, str)
+    def add(self, name, result, feedback=None):
+        rowCount = self.rowCount()
+        self.beginInsertRows(QModelIndex(), rowCount, rowCount)
+        test = {b'test': Result(name, result, feedback)}
+        self._data.append(test)
+        self.endInsertRows()
+        return test
+
+    @Slot(str)
+    def start(self, name):
+        """
+        Method called to either add a new test, or re-start an existing one.
+        If the name-d test is found its 'content' will be cleared and restarted.
+        If it is not found the test will be added to the list and executed.
+        :param name: unique name of the test
+        :return: None
+        """
+        existing = False
+        for row in range(len(self._data)):
+            test = self._data[row][self.TestKey]
+            if test.name == name:
+                test.result = Result.StateRunning
+                ix = self.index(row, 0)
+                self._setcurrentTestIndex(row)
+                self.dataChanged.emit(ix, ix, self.roleNames())
+                existing = True
+                break
+        if not existing:
+            self.add(name, Result.StateRunning)
+            self._setcurrentTestIndex(len(self._data) - 1)
+
+    @Slot(str, str)
+    def end(self, name, result):
+        """
+        Method called to end a test.
+        Only updated if test is found. If no tests with name exist, nothing is done.
+        :param name: unique name of the test
+        :param result: test result for the suite
+        :return: None
+        """
+        for row in range(len(self._data)):
+            test = self._data[row][self.TestKey]
+            if test.name == name:
+                test.result = result
+                test.progress = 1
+                ix = self.index(row, 0)
+                self.dataChanged.emit(ix, ix, self.roleNames())
+                break
+
+    @Slot(str, int)
+    def progress(self, name, progress):
+        """
+        Method called to end a test.
+        Only updated if test is found. If no tests with name exist, nothing is done.
+        :param name: unique name of the test
+        :param progress: 0 to 100 for percentage of test progress.
+        :return: None
+        """
+        for row in range(len(self._data)):
+            test = self._data[row][self.TestKey]
+            if test.name == name:
+                test.progress = progress / 100
+                ix = self.index(row, 0)
+                self.dataChanged.emit(ix, ix, self.roleNames())
+                break
+
+    @Slot(str, str)
+    def setFeedback(self, key, feedback):
+        existing = False
+        for row in range(len(self._data)):
+            test = self._data[row][self.TestKey]
+            if test.name == key:
+                test.feedback = feedback
+                ix = self.index(row, 0)
+                self.dataChanged.emit(ix, ix, self.roleNames())
+                existing = True
+                break
+        if not existing:
+            self.add(key, None, feedback)
+
+    @Slot()
+    def clear(self):
+        rowCount = self.rowCount(QModelIndex())
+        if rowCount:
+            self.beginRemoveRows(QModelIndex(), 0, rowCount - 1)
+            self._data.clear()
+            self.endRemoveRows()
+
+    @Slot(list, bool)
+    def populateTests(self, tests, clear):
+        if clear:
+            self.removeRows(0, self.rowCount(QModelIndex()))
+        if tests:
+            for test in tests:
+                self.add(test, None)
+
+    def removeRows(self, position, rows, parent=QtCore.QModelIndex()):
+        self.beginRemoveRows(parent, position, position + rows - 1)
+        del self._data[position:position + rows]
+        self.endRemoveRows()
+        return True
+
+    def _setcurrentTestIndex(self, currentTestIndex):
+        """ Setter for currentTestIndex Property """
+        changed = False
+        with self.lock:
+            if self._currentTestIndex != currentTestIndex:
+                self._currentTestIndex = currentTestIndex
+                changed = True
+        if changed:
+            self.currentTestIndex_changed.emit()
+
+    def _getcurrentTestIndex(self):
+        """ Getter for currentTestIndex Property """
+        with self.lock:
+            index = self._currentTestIndex
+        return index
+
+    currentTestIndex_changed = Signal()
+    currentTestIndex = Property(int, _getcurrentTestIndex, _setcurrentTestIndex, notify=currentTestIndex_changed)

testexecutor/model/TestSuiteControlModel.py

@@ -0,0 +1,139 @@
+#  Copyright 2020 Direkt, Australia
+#  Copyright 2021 Direkt Embedded Pty Ltd
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import threading
+from PySide6.QtCore import QObject
+from PySide6.QtCore import Signal, Property, Slot
+from .selector.MultiSelectListModel import MultiSelectListModel
+from testexecutor.model.selector.FilterGroupModel import FilterGroupModel
+
+
+class TestSuiteControlModel(QObject):
+    """
+    A Test Suite Control is a model for selecting tests to be executed. The tests can be filtered.
+    """
+
+    def __init__(self, filtercallback=None, filters=None):
+        """
+        The suite control calls the supplied callback when a change occurs in the filters. The callback is to the
+        execution test system, and should return a list of suites and associated tests, as well as a new set of
+        allowed filters, given the new suites and tests.
+        These will be 'merged' with the current suite and tests in the test selector.
+        What the filters are and how the filters effect the list of tests is entirely up to the calling test system.
+        Once the user has filtered and/or selected the tests, the getTests() method can be used by the test system
+        to get the list of suites and tests to execute. If this model is used in conjunction with the TestSuiteModel
+        then the test run will be seen on that associated UI.
+        :param filtercallback: Callback executed when a filter item changes, including on first creation
+        :param filters: A list of filter groups to be displayed
+        """
+        QObject.__init__(self)
+        self.lock = threading.RLock()
+        self._testselector = MultiSelectListModel()
+        self._filterchangedcallback = filtercallback
+        self._errors = ""
+        if filters:
+            self._filter_changed_signal = Signal()
+            self._filters = FilterGroupModel(filters, onSelectedChanged=self.on_filters_changed)
+
+    @Slot(str, object)
+    def on_filters_changed(self, name, selected):
+        try:
+            self._filterchangedcallback(name, selected)
+        except Exception as err:
+            self.errors = str(err)
+
+    def _setfilters(self, filters):
+        """ Setter for filters Property """
+        changed = False
+        with self.lock:
+            if self._filters != filters:
+                self._filters = filters
+                changed = True
+        if changed:
+            self.filters_changed.emit()
+
+    def _getfilters(self):
+        """
+        Getter for filters Property
+        """
+        filters = None
+        with self.lock:
+            filters = self._filters
+        return filters
+
+    """
+    Filters is a list of possible filter controls that can be used to control the suite filtering.
+    Each filter is then another list of items which are the filtering 'fields'
+    """
+    filters_changed = Signal()
+    filters = Property(QObject, _getfilters, _setfilters, notify=filters_changed)
+
+
+    def _settestselector(self, testselector):
+        """ Setter for testselector Property """
+        changed = False
+        with self.lock:
+            if self._testselector != testselector:
+                self._testselector = testselector
+                changed = True
+        if changed:
+            self.testselector_changed.emit()
+
+    def _gettestselector(self):
+        """
+        Getter for testselector Property
+        """
+        testselector = None
+        with self.lock:
+            testselector = self._testselector
+        return testselector
+
+    """
+    testselector is a tree of suites and associated tests which can be selected to create a subset of tests
+    to be executed.
+    Should be of type TreeSelectorModel
+    """
+    testselector_changed = Signal()
+    testselector = Property(QObject, _gettestselector, _settestselector, notify=testselector_changed)
+
+    def _seterrors(self, errors):
+        """ Setter for errors Property """
+        changed = False
+        with self.lock:
+            if self._errors != errors:
+                self._errors = errors
+                changed = True
+        if changed:
+            self.errors_changed.emit()
+
+    def _geterrors(self):
+        """
+        Getter for errors Property
+        """
+        errors = None
+        with self.lock:
+            errors = self._errors
+        return errors
+
+    """
+    errors is a tree of suites and associated tests which can be selected to create a subset of tests
+    to be executed.
+    Should be of type TreeSelectorModel
+    """
+    errors_changed = Signal()
+    errors = Property(str, _geterrors, _seterrors, notify=errors_changed)
+
+    def selectedItems(self):
+        return self._testselector.selectedItems()