Esempio n. 1
0
def _get():
    '''
    Gets channels defined in the settings.
    '''
    channels = []
    modules = iter(utils.packageModules(_package()))
    for name in settings.get(CONFIG_NAME, force=True):
        if name in _cache:
            # A name of the channel conflicts with some predefined channel
            continue
        params = {}
        section = settings.get(CONFIG_NAME, name, force=True)
        for option in section:
            params[option.name().lower()] = option
        clsname = params.pop("class", None)
        if clsname is None:
            continue
        clsname = clsname.get()
        while clsname not in _registry:
            try:
                while not utils.importModule(modules.next()):
                    pass
            except StopIteration:
                break
        if clsname in _registry:
            channels.append(_registry[clsname](name, **params))
    return channels
Esempio n. 2
0
 def testValueAddExistingSection(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test")
     settings.get(TEST_FILE_NAME, "Test", "test_1", force=True).set("1")
     self.assertEqual(settings._META_OPTION_VALUE,
             config.get(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     self.assertEqual("1", config.get(TEST_FILE_NAME, "Test", "test_1"))
Esempio n. 3
0
def load(type=None):
    '''
    Loads all configured devices using the given device type.

    :param type: A device class
    :type type: type
    '''
    global _cache
    if _cache is None:
        _cache = {}
    devices = []
    for name in settings.get(CONFIG_NAME, force=True):
        devices.append(name)
        if name in _cache:
            continue
        params = {}
        for option in settings.get(CONFIG_NAME, name, force=True):
            params[option.name()] = option
        try:
            _add(name, type or Device, **params)
        except:
            # FIXME: Log the error?
            pass
    for name in _cache.keys():
        if name not in devices:
            del _cache[name]
Esempio n. 4
0
 def testAddSettingOption(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     self.assertFalse(settings._META_OPTION_NAME in config.get(
                                                    TEST_FILE_NAME, "Test"))
     settings.get(TEST_FILE_NAME, "Test", force=True)
     self.assertTrue(settings._META_OPTION_NAME in config.get(
                                                    TEST_FILE_NAME, "Test"))
Esempio n. 5
0
 def testValueGet(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertEqual("1", item.get())
     self.assertEqual("1", str(item))
     self.assertEqual("", str(settings.get(TEST_FILE_NAME,
                                                     "Test", "test_2")))
Esempio n. 6
0
 def testValueGetNotSettings(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     config.set(TEST_FILE_NAME, "Test", "test_2", "11")
     self.assertEqual(None, settings.get(TEST_FILE_NAME,
                                                      "Test", "test_1"))
     self.assertEqual("1", settings.get(TEST_FILE_NAME,
                                      "Test", "test_1", force=True).get())
     self.assertTrue(settings._META_OPTION_NAME in config.get(
                                                 TEST_FILE_NAME, "Test"))
     self.assertEqual(config.get(
                     TEST_FILE_NAME, "Test", settings._META_OPTION_NAME),
                                             settings._META_OPTION_VALUE)
Esempio n. 7
0
 def testValueGet(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     config.set(TEST_FILE_NAME, "Test", "test_2", "11")
     self.assertTrue(TEST_FILE_NAME in settings.get())
     self.assertTrue("Test" in settings.get(TEST_FILE_NAME))
     self.assertEqual(["test_1", "test_2"],
                        sorted([s.name() for s in settings.get(
                                                 TEST_FILE_NAME, "Test")]))
     self.assertEqual("11", settings.get(TEST_FILE_NAME,
                                                   "Test", "test_2").get())
Esempio n. 8
0
 def updateOption(self, item, column):
     '''
     Finishes editing an option item and saves changes to settings.
     '''
     if column == 0:
         self._optionsTree.closePersistentEditor(item, 0)
         data = item.customData[:]
         settings.get(*data).remove()
         data[-1] = item.text(0)
         settings.set(*data, value=item.text(1), force=True)
     elif column == 1:
         self._optionsTree.closePersistentEditor(item, 1)
         data = item.customData[:]
         data.append(item.text(1))
         settings.get(*data[:-1]).set(data[-1])
Esempio n. 9
0
 def addSetting(self):
     '''
     Adds new settings option or section.
     '''
     cData = self._optionsTree.currentItem().customData
     name, ok = QtGui.QInputDialog.getText(None, 'Enter name', 'Enter name')
     if ok and name != '':
         if cData[1] is None:
             settings.get(cData[0], name, force=True)
         else:
             value, ok = QtGui.QInputDialog.getText(None, 'Enter value',
                                                    'Enter value')
             if ok:
                 settings.get(cData[0], cData[1], name).set(value)
         self._reloadTree(self._optionsTree.currentItem())
Esempio n. 10
0
 def addSetting(self):
     '''
     Adds new settings option or section.
     '''
     cData = self._optionsTree.currentItem().customData
     name, ok = QtGui.QInputDialog.getText(None, 'Enter name', 'Enter name')
     if ok and name != '':
         if cData[1] is None:
             settings.get(cData[0], name, force=True)
         else:
             value, ok = QtGui.QInputDialog.getText(None, 'Enter value',
                                                    'Enter value')
             if ok:
                 settings.get(cData[0], cData[1], name).set(value)
         self._reloadTree(self._optionsTree.currentItem())
Esempio n. 11
0
 def updateOption(self, item, column):
     '''
     Finishes editing an option item and saves changes to settings.
     '''
     if column == 0:
         self._optionsTree.closePersistentEditor(item, 0)
         data = item.customData[:]
         settings.get(*data).remove()
         data[-1] = item.text(0)
         settings.set(*data, value=item.text(1), force=True)
     elif column == 1:
         self._optionsTree.closePersistentEditor(item, 1)
         data = item.customData[:]
         data.append(item.text(1))
         settings.get(*data[:-1]).set(data[-1])
Esempio n. 12
0
 def __init__(self):
     section = settings.get(CONFIG_NAME, self.name, force=True)
     self._enabled = section["enabled"]
     self._dirs = section["dirs"]
     self._pattern = section["pattern"]
     self._recursive = section["recursive"]
     self._links = section["links"]
Esempio n. 13
0
 def __init__(self):
     section = settings.get(CONFIG_NAME, self.name, force=True)
     self._enabled = section["enabled"]
     self._dirs = section["dirs"]
     self._pattern = section["pattern"]
     self._recursive = section["recursive"]
     self._links = section["links"]
Esempio n. 14
0
 def testValueGetName(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertEqual("test_1", item.name())
Esempio n. 15
0
 def testTupleValue(self):
     TEST_FILE_NAME = self._filenames[0]
     value = (1, "item2", False)
     config.set(TEST_FILE_NAME, "Test", "test_1", value)
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     self.assertEqual([str(v) for v in value], settings.get(
                            self._filenames[0], "Test", "test_1").getList())
Esempio n. 16
0
def _section(name, **params):
    '''
    Returns settings section representing a device given by its parameters.
    '''
    section = settings.get(CONFIG_NAME, name, force=True)
    for param, value in params.iteritems():
        section[param] = value
    return section
Esempio n. 17
0
 def tearDown(self):
     self.coreDumps.stop()
     section = settings.get(channels.CONFIG_NAME,
                            self.coreDumps.name, force=True)
     section["dirs"] = self._origDirs
     section["pattern"] = self._origPattern
     if os.path.exists(self._TEST_CORE_DIR):
         shutil.rmtree(self._TEST_CORE_DIR)
Esempio n. 18
0
 def testValueAddExistingSection(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test")
     item = settings.get(TEST_FILE_NAME, "Test", force=True)
     item["test_1"] = "1"
     self.assertEqual(settings._META_OPTION_VALUE,
             config.get(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     self.assertEqual("1", config.get(TEST_FILE_NAME, "Test", "test_1"))
Esempio n. 19
0
 def testListValue(self):
     TEST_FILE_NAME = self._filenames[0]
     value = ["item1", "item2", "item3"]
     config.set(TEST_FILE_NAME, "Test", "test_1", value)
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     self.assertEqual(value, settings.get(self._filenames[0],
                                               "Test", "test_1").getList())
Esempio n. 20
0
def _section(name, **params):
    '''
    Returns settings section representing a device given by its parameters.
    '''
    section = settings.get(CONFIG_NAME, name, force=True)
    for param, value in params.iteritems():
        section[param] = value
    return section
Esempio n. 21
0
 def testRemoveSettings(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item_1 = settings.get(TEST_FILE_NAME, "Test")
     item_1.remove()
     self.assertFalse("Test" in config.get(TEST_FILE_NAME))
Esempio n. 22
0
 def testValueAddToNewFile(self):
     TEST_FILE_NAME = self._filenames[0]
     self.assertFalse("Test" in config.get(TEST_FILE_NAME))
     item = settings.get(TEST_FILE_NAME, "Test", "test_1", force=True)
     self.assertTrue("Test" in config.get(TEST_FILE_NAME))
     item.set("1")
     self.assertEqual(settings._META_OPTION_VALUE,
             config.get(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     self.assertEqual("1", config.get(TEST_FILE_NAME, "Test", "test_1"))
Esempio n. 23
0
 def tearDown(self):
     self.coreDumps.stop()
     section = settings.get(channels.CONFIG_NAME,
                            self.coreDumps.name,
                            force=True)
     section["dirs"] = self._origDirs
     section["pattern"] = self._origPattern
     if os.path.exists(self._TEST_CORE_DIR):
         shutil.rmtree(self._TEST_CORE_DIR)
Esempio n. 24
0
 def setUp(self):
     self.coreDumps = channels.CoreDumpsChannel()
     section = settings.get(channels.CONFIG_NAME,
                            self.coreDumps.name, force=True)
     self._origDirs = str(section["dirs"])
     section["dirs"] = ''
     self._origPattern = str(section["pattern"])
     section["pattern"] = self._TEST_CORE_PATTERN
     self.coreDumps.start(None)
Esempio n. 25
0
 def testValueRemove(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertTrue("test_1" in config.get(TEST_FILE_NAME, "Test"))
     item.remove()
     self.assertFalse("test_1" in config.get(TEST_FILE_NAME, "Test"))
Esempio n. 26
0
 def testValueGet(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     config.set(TEST_FILE_NAME, "Test", "test_2", "11")
     item = settings.get(TEST_FILE_NAME, "Test")
     self.assertEqual("11", item["test_2"].get())
     self.assertTrue(item["test_5"].get() is None)
Esempio n. 27
0
 def setUp(self):
     self.coreDumps = channels.CoreDumpsChannel()
     section = settings.get(channels.CONFIG_NAME,
                            self.coreDumps.name,
                            force=True)
     self._origDirs = str(section["dirs"])
     section["dirs"] = ''
     self._origPattern = str(section["pattern"])
     section["pattern"] = self._TEST_CORE_PATTERN
     self.coreDumps.start(None)
Esempio n. 28
0
 def testIter(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     refDict = {"test_1": "1", "test_2": "2"}
     for key, value in refDict.iteritems():
         config.set(TEST_FILE_NAME, "Test", key, value)
     item = settings.get(TEST_FILE_NAME, "Test")
     for option in item:
         self.assertTrue(option.name() in refDict, option)
         self.assertEqual(option.get(), refDict[option.name()])
Esempio n. 29
0
 def testGetInt(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertEqual(1, item.getInt())
     self.assertEqual(1, int(item))
     config.set(TEST_FILE_NAME, "Test", "test_1", "True")
     self.assertTrue(item.getInt() is None)
     self.assertEqual(0, int(item))
Esempio n. 30
0
 def testValueAddWrongSettOptVal(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME, "Test")
     self.assertNotEqual(settings._META_OPTION_VALUE,
         config.get(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     item = settings.get(TEST_FILE_NAME, "Test", "test_1", force=True)
     item.set("1")
     self.assertTrue(settings._META_OPTION_NAME in config.get(
                                                    TEST_FILE_NAME, "Test"))
     self.assertEqual(settings._META_OPTION_VALUE, config.get(
                        TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     self.assertEqual("1", config.get(TEST_FILE_NAME, "Test", "test_1"))
Esempio n. 31
0
 def testValueAddWrongSettOptVal(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME, "Test")
     self.assertNotEqual(settings._META_OPTION_VALUE,
             config.get(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     item = settings.get(TEST_FILE_NAME, "Test", force=True)
     item["test_1"] = "1"
     self.assertTrue(settings._META_OPTION_NAME in config.get(
                                                    TEST_FILE_NAME, "Test"))
     self.assertEqual(settings._META_OPTION_VALUE, config.get(
                        TEST_FILE_NAME, "Test", settings._META_OPTION_NAME))
     self.assertEqual("1", config.get(TEST_FILE_NAME, "Test", "test_1"))
Esempio n. 32
0
 def _updateTree(self, parent=None, name=None, section=None):
     '''
     Fills the tree with settings options.
     '''
     if not parent:
         self._optionsTree.clear()
         for name in sorted(settings.get()):
             if settings.get(name) is not None:
                 settItem = QtGui.QTreeWidgetItem(self._optionsTree, [
                     name,
                     "",
                 ])
                 settItem.customData = [name, None, None]
                 self._updateTree(settItem, name)
     elif parent and name and not section:
         for section in sorted(settings.get(name)):
             if settings.get(name, section) is not None:
                 sectionItem = QtGui.QTreeWidgetItem(
                     parent, [
                         section,
                         "",
                     ])
                 sectionItem.customData = [name, section, None]
                 self._updateTree(sectionItem, name, section)
     elif parent and name and section:
         if settings.get(name, section) is not None:
             for option in sorted(settings.get(name, section),
                                  key=lambda s: s.name()):
                 optionItem = QtGui.QTreeWidgetItem(
                     parent, [option.name(), str(option)])
                 optionItem.customData = [name, section, option.name()]
Esempio n. 33
0
 def _updateTree(self, parent=None, name=None, section=None):
     '''
     Fills the tree with settings options.
     '''
     if not parent:
         self._optionsTree.clear()
         for name in sorted(settings.get()):
             if settings.get(name) is not None:
                 settItem = QtGui.QTreeWidgetItem(self._optionsTree,
                                                  [name, "",])
                 settItem.customData = [name, None, None]
                 self._updateTree(settItem, name)
     elif parent and name and not section:
         for section in sorted(settings.get(name)):
             if settings.get(name, section) is not None:
                 sectionItem = QtGui.QTreeWidgetItem(parent, [section, "",])
                 sectionItem.customData = [name, section, None]
                 self._updateTree(sectionItem, name, section)
     elif parent and name and section:
         if settings.get(name, section) is not None:
             for option in sorted(settings.get(name, section),
                                  key=lambda s: s.name()):
                 optionItem = QtGui.QTreeWidgetItem(parent,
                                             [option.name(), str(option)])
                 optionItem.customData = [name, section, option.name()]
Esempio n. 34
0
 def setUp(self):
     self._origChannels = testresult.channels
     testresult.channels = commons.DummyChannels(coreDumps=True)
     self.testResult = TestResult()
     section = settings.get(channels.CONFIG_NAME,
                            self.testResult._coreDumps.name, force=True)
     self._origDirs = str(section["dirs"])
     section["dirs"] = self._TEST_CORE_DIR
     self._origPattern = str(section["pattern"])
     section["pattern"] = self._TEST_CORE_PATTERN
     if not os.path.exists(self._TEST_CORE_DIR):
         os.mkdir(self._TEST_CORE_DIR)
     self.testResult.start(None)
Esempio n. 35
0
    def removeSetting(self):
        '''
        Remove settings option, section of file.
        '''
        rep = QtGui.QMessageBox.warning(
            None, "Are You sure ?", """Delete this settings ?\n
Settings will be deleted and they may be reverted to default
values when application will need this""", QtGui.QMessageBox.Yes,
            QtGui.QMessageBox.No)
        if rep == QtGui.QMessageBox.Yes:
            cData = self._optionsTree.currentItem().customData
            option = settings.get(cData[0], cData[1], cData[2])
            option.remove()
            self._reloadTree(self._optionsTree.currentItem().parent())
Esempio n. 36
0
    def removeSetting(self):
        '''
        Remove settings option, section of file.
        '''
        rep = QtGui.QMessageBox.warning(None, "Are You sure ?",
        """Delete this settings ?\n
Settings will be deleted and they may be reverted to default
values when application will need this""",
                QtGui.QMessageBox.Yes, QtGui.QMessageBox.No)
        if rep == QtGui.QMessageBox.Yes:
            cData = self._optionsTree.currentItem().customData
            option = settings.get(cData[0], cData[1], cData[2])
            option.remove()
            self._reloadTree(self._optionsTree.currentItem().parent())
Esempio n. 37
0
 def setUp(self):
     self._origChannels = testresult.channels
     testresult.channels = commons.DummyChannels(coreDumps=True)
     self.testResult = TestResult()
     section = settings.get(channels.CONFIG_NAME,
                            self.testResult._coreDumps.name,
                            force=True)
     self._origDirs = str(section["dirs"])
     section["dirs"] = self._TEST_CORE_DIR
     self._origPattern = str(section["pattern"])
     section["pattern"] = self._TEST_CORE_PATTERN
     if not os.path.exists(self._TEST_CORE_DIR):
         os.mkdir(self._TEST_CORE_DIR)
     self.testResult.start(None)
Esempio n. 38
0
 def testGetBool(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     config.set(TEST_FILE_NAME, "Test", "test_1", "True")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertEqual(True, item.getBool())
     self.assertEqual(True, bool(item))
     config.set(TEST_FILE_NAME, "Test", "test_1", "False")
     self.assertEqual(False, item.getBool())
     self.assertEqual(False, bool(item))
     config.set(TEST_FILE_NAME, "Test", "test_1", "Name")
     self.assertEqual(None, item.getBool())
     self.assertEqual(False, bool(item))
Esempio n. 39
0
 def testHaveSettings(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", "test_1", "True")
     self.assertTrue(settings.get(TEST_FILE_NAME, "Test") is None)
     self.assertTrue(settings.get(TEST_FILE_NAME, "Test", "test_1") is None)
     self.assertTrue(settings.get(TEST_FILE_NAME, "Test2") is None)
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     self.assertFalse(settings.get(TEST_FILE_NAME, "Test") is None)
     self.assertFalse(settings.get(TEST_FILE_NAME, "Test", "test_1") is None)
     self.assertTrue(settings.get(TEST_FILE_NAME, "Test2") is None)
Esempio n. 40
0
 def testValueGetSettingsOption(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", settings._META_OPTION_NAME,
                                              settings._META_OPTION_VALUE)
     self.assertEqual(None, settings.get(TEST_FILE_NAME,
                                  "Test", settings._META_OPTION_NAME))
Esempio n. 41
0
class Test(View):
    '''
    A view for running test cases.
    '''
    NAME = viewName()
    _UI_FILE = "test_view.ui"
    _ICON_FILE = ":/test/icons/system-run.png"

    _checkOnConnect = settings.get(NAME,
                                   "options",
                                   "check_on_connect",
                                   default="Yes",
                                   force=True)

    # Menus and Tool bar
    _menuFile = ("actionAdd", "actionRemove", None)
    _menuEdit = ("actionExpand", "actionExpandAll", "actionCollapse",
                 "actionCollapseAll", None)
    _menuView = ("actionRefresh", None)
    _toolBar = ("actionAdd", "actionRemove", None, ("actionExpand",
                                                    "actionExpandAll"),
                ("actionCollapse", "actionCollapseAll"), "actionRefresh", None,
                "actionStart", "actionPause", "actionResume", "actionStop")

    def __init__(self, parent):
        View.__init__(self, parent)
        self._devices = TestDeviceList(self._elements["treeWidgetDevices"])

        self._actionStart = self._elements["actionStart"]
        self._actionStop = self._elements["actionStop"]
        self._actionPause = self._elements["actionPause"]
        self._actionResume = self._elements["actionResume"]

        self._actionStart.triggered.connect(self._startTests)
        self._actionStop.triggered.connect(self._stopTests)
        self._actionPause.triggered.connect(self._pauseTests)
        self._actionResume.triggered.connect(self._resumeTests)

        self._actionStart.setVisible(True)
        self._actionStop.setVisible(False)
        self._actionPause.setVisible(False)
        self._actionResume.setVisible(False)

        # Summary channel
        channels.add("SummaryChannel", "_ui_summary")

        # Progress channel
        pBar = QtGui.QProgressBar()
        pBar.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
        font = pBar.font()
        font.setBold(True)
        pBar.setFont(font)
        self._parent.getStatusBar().addPermanentWidget(pBar, 1)
        self._progress = ProgressChannelHelper(pBar)
        channels.add(ProgressChannel, "_ui_progress", progress=self._progress)
        self._progress.testStarted.connect(self._onTestStarted)
        self._progress.testStopped.connect(self._onTestStopped)
        self._progress.stopped.connect(self._onStopped)

        self._tests = Tests(self._elements["treeWidgetLocations"],
                            self._elements["treeWidgetTests"],
                            self._elements["treeWidgetModels"])

        self._elements["actionAdd"].triggered.connect(self._tests.addLocation)
        self._elements["actionRemove"].triggered.connect(
            self._tests.removeLocation)
        self._elements["actionExpand"].triggered.connect(
            self._tests.expandSelected)
        self._elements["actionExpandAll"].triggered.connect(
            self._tests.expandAll)
        self._elements["actionCollapse"].triggered.connect(
            self._tests.collapseSelected)
        self._elements["actionCollapseAll"].triggered.connect(
            self._tests.collapseAll)
        self._elements["actionRefresh"].triggered.connect(self._tests.refresh)

        # Initialize private test variables
        self._suiteRuns = 0
        self._todoSuites = 0
        self._testResult = None
        self._testRunner = None

# Public methods:

    def saveState(self):
        '''
        Saves the view's state to configuration.
        '''
        View.saveState(self)
        self._tests.saveState()

    def loadState(self):
        '''
        Loads the view's state from configuration.
        '''
        View.loadState(self)
        self._tests.loadState()

# Slots:
#@QtCore.Slot(Device)

    def _deviceConnected(self, device):
        '''
        Adds a device to list.
        '''
        self._devices.add(device, check=self._checkOnConnect.getBool())

    #@QtCore.Slot(Device)
    def _deviceDisconnected(self, device, error):
        '''
        Removes given device from list. The error parameter can be set to True
        to indicate that the device was disconnected due to an error.
        '''
        self._devices.remove(device)

    #@QtCore.Slot()
    def _startTests(self):
        '''
        Starts execution of tests.
        '''
        log.debug("Starting tests")
        self._actionStart.setVisible(False)
        devices = self._devices.getChecked()
        if not devices:
            runWarning("Select some devices first")
            self._actionStart.setVisible(True)
            return
        tests = self._tests.getCheckedTests()
        if not tests:
            self._actionStart.setVisible(True)
            return
        if sum([test.count() for test in tests]) == 0:
            runWarning("Selected test suites do not contain any test cases")
            self._actionStart.setVisible(True)
            return

        self._suiteRuns = 0
        self._todoSuites = len(tests)
        self._testResult = testresult.TestResult()
        self._testRunner = TestRunner(devices, tests, self._testResult)
        self._devices.deviceChecked.connect(self._testRunner.addDevice)
        self._devices.deviceUnchecked.connect(self._testRunner.removeDevice)
        self._devices.setWarning(True)

        self._testRunner.start()

        self._actionStop.setVisible(True)
        self._actionPause.setVisible(True)

    #@QtCore.Slot()
    def _stopTests(self):
        '''
        Stops execution of tests.
        '''
        log.debug("Stopping tests")
        self._actionStart.setVisible(True)
        self._actionStop.setVisible(False)
        self._actionPause.setVisible(False)
        self._actionResume.setVisible(False)
        self._testRunner.stop()

    #@QtCore.Slot()
    def _pauseTests(self):
        '''
        Pauses execution of tests.
        '''
        log.debug("Pausing tests")
        self._actionStart.setVisible(False)
        self._actionStop.setVisible(True)
        self._actionPause.setVisible(False)
        self._actionResume.setVisible(True)
        self._testRunner.pause()

    #@QtCore.Slot()
    def _resumeTests(self):
        '''
        Resumes execution of tests.
        '''
        log.debug("Resuming tests")
        self._actionStart.setVisible(False)
        self._actionStop.setVisible(True)
        self._actionPause.setVisible(True)
        self._actionResume.setVisible(False)
        self._testRunner.resume()

    #@QtCore.Slot(testresult.TestResultBase, testresult.DeviceExecResult)
    def _onTestStarted(self, result, device):
        '''
        Handles a start test execution of a test represented by the given
        result.
        '''
        if isinstance(result, testresult.TestCaseResult):
            log.debug("Began execution of test case: %s" % result.id)
        # If it is a top-level test suite result then increase the counter of
        # running top-level test suites
        if result.parent is None:
            self._suiteRuns += 1

    #@QtCore.Slot(testresult.TestResultBase, testresult.DeviceExecResult)
    def _onTestStopped(self, result, device):
        '''
        Handles a stop test execution of a test represented by the given
        result.
        '''
        if isinstance(result, testresult.TestCaseResult):
            log.debug("Finished execution of test case: %s" % result.id)
        # If it is a top-level test suite result then decrease the counters of
        # running top-level test suites and to do test suites.
        if result.parent is None:
            self._suiteRuns -= 1
            self._todoSuites -= 1
            # If all top-level test suites are done then join() the test runner
            if self._suiteRuns == 0 and self._todoSuites <= 0:
                self._testRunner.join()

    #@QtCore.Slot()
    def _onStopped(self):
        '''
        Shows summary dialog after finishing test executions.
        '''
        log.debug("All tests finished")

        self._actionStart.setVisible(True)
        self._actionStop.setVisible(False)
        self._actionPause.setVisible(False)
        self._actionResume.setVisible(False)

        self._devices.deviceChecked.disconnect(self._testRunner.addDevice)
        self._devices.deviceUnchecked.disconnect(self._testRunner.removeDevice)
        self._devices.setWarning(False)

        files = []
        for c in self._testRunner.result.get():
            if isinstance(c, channels.TestResultFileChannel) and c.isActive():
                files.append((c.name, c.filePath()))
        dialog = ReportDialog(
            self._testResult.get(name='_ui_summary')[0].getSummary(), files,
            len(self._devices.getChecked()) > 0)
        dialog.closed.connect(self._progress.reset,
                              type=QtCore.Qt.DirectConnection)
        dialog.runAgainClicked.connect(self._startTests,
                                       type=QtCore.Qt.QueuedConnection)
        dialog.showDetailsClicked.connect(self._showDetails)
        dialog.run()

    #@QtCore.Slot()
    def _showDetails(self):
        '''
        Shows execution result in Result view.
        '''
        resultView = self._parent.getView("result")
        if resultView is not None:
            log.debug("Showing details in Result view")
            resultView.activate()
            resultView.showLastResult()
Esempio n. 42
0
 def testValueGetNotSettingsSection(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     item = settings.get(TEST_FILE_NAME, "Test", "test_1")
     self.assertEqual(None, item)
Esempio n. 43
0
 def testValueGetNotSettingsSections(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME, "Test", "test_1", "1")
     config.set(TEST_FILE_NAME, "Test", "test_1", "11")
     self.assertFalse("Test" in settings.get(TEST_FILE_NAME))
     self.assertTrue("Test" in settings.get(TEST_FILE_NAME, force=True))
Esempio n. 44
0
 def testValueGetNotSettingsName(self):
     TEST_FILE_NAME = self._filenames[0]
     config.set(TEST_FILE_NAME)
     self.assertFalse(TEST_FILE_NAME in settings.get())
     self.assertTrue(TEST_FILE_NAME in settings.get(force=True))
Esempio n. 45
0
class ResultTab(QtCore.QObject):
    '''
    Represents tab containing test results.
    '''
    _RESULT_TAB_UI = "result_tab.ui"
    _COLUMN_COUNT = 3

    _ICONS = {
        "directory": QtGui.QIcon(":/result/icons/folder-grey.png"),
        "module": QtGui.QIcon(":/result/icons/text-x-python.png"),
        "suite": QtGui.QIcon(":/result/icons/source_moc.png"),
        "case": QtGui.QIcon(":/result/icons/inode-blockdevice.png"),
        "step": QtGui.QIcon(":/result/icons/application-x-zip.png")
    }

    _expandStatuses = settings.get(viewName(),
                                   "options",
                                   "expand_statuses",
                                   default=",".join(
                                       (STATUS_ERROR, STATUS_FAILED)),
                                   force=True)

    def __init__(self, view, result, select, closable):
        '''
        Initializes tab with test results. The parameters are:
        - view: instance of ResultView
        - result: a test result instance
        - select: a boolean that determines whether tree items should be
            selected on adding
        - closable: a boolean that determines if tab can be closed manually
        '''
        QtCore.QObject.__init__(self)
        self._view = view
        elements = view.loadUi(self._RESULT_TAB_UI)
        self.tab = elements["Tab"]
        self._treeWidget = elements["treeWidget"]
        self._treeWidget.currentItemChanged.connect(self.display)
        self._treeWidget.itemExpanded.connect(self._updateOnExpand)
        self._treeWidget.itemCollapsed.connect(self._updateOnCollapse)
        self._closable = closable

        for res in result:
            log.debug("Adding tree item(s) for result '%s'" % res.id)
            self._addItem(res, None, select)
            for i in xrange(self._COLUMN_COUNT):
                self._treeWidget.resizeColumnToContents(i)

# Private methods:

    def _getItem(self, id, force=False):
        '''
        Returns an item related to a test result of given ID. If force is set
        to True, then an item will be created if it does not exist yet.
        '''
        sections = id.split(".")
        matchedItem = None
        parent = self._treeWidget
        for i in xrange(len(sections)):
            matchedItem = None
            if i == 0:
                for j in xrange(parent.topLevelItemCount()):
                    item = parent.topLevelItem(j)
                    if item.testName == sections[0]:
                        matchedItem = item
                        break
            else:
                for j in xrange(parent.childCount()):
                    item = parent.child(j)
                    if item.testName == ".".join(sections[:i + 1]):
                        matchedItem = item
                        break
            if matchedItem is None:
                if not force:
                    return None
                item = ResultItem(parent, testName=".".join(sections[:i + 1]))
                item.setText(0, sections[i])
                item.setIcon(0, self._ICONS["directory"])
                parent = item
            else:
                parent = matchedItem

        return parent

    def _addItem(self, result, parent, select):
        '''
        Adds items to the tree based on given result and its descendants.
        The select boolean determines whether items should be selected.
        '''
        item = None
        if parent is None:
            item = self._getItem(result.id)
            if item is None:
                parent = self._getItem(".".join(result.id.split(".")[:-1]),
                                       force=True)
        if item is None:
            item = ResultItem(parent, testName=result.id, testResult=result)
            if isinstance(result, TestSuiteResult):
                item.setIcon(0, self._ICONS["suite"])
                if item.parent().testResult is None:
                    item.parent().setIcon(0, self._ICONS["module"])
            elif isinstance(result, TestCaseResult):
                item.setIcon(0, self._ICONS["case"])
            elif isinstance(result, TestStepResult):
                item.setIcon(0, self._ICONS["step"])
            item.setText(1, result.id.rsplit(".", 1)[1])
            self._setItemStatus(item)
        if select:
            self._treeWidget.setCurrentItem(item)
        for childResult in result.children:
            self._addItem(childResult, item, select)

    def _setItemStatus(self, item):
        '''
        Sets color of a tree item adequately to status of its result and fills
        the 'Pass rate' column
        '''
        color = STATUS_COLORS[item.testResult.status]
        item.setForeground(1, color)
        item.setForeground(2, color)
        item.setFont(1, STATUS_FONTS[item.testResult.status])
        if isinstance(item.testResult, (TestCaseResult, TestSuiteResult)):
            i = p = 0
            for c in item.testResult.children:
                i += 1
                if c.status == STATUS_PASSED:
                    p += 1
            item.setText(2, "%d of %d" % (p, i))
        item.setTextAlignment(2, QtCore.Qt.AlignHCenter)

# Public methods:

    def isClosable(self):
        '''
        Returns True if tab can be closed or False otherwise.
        '''
        return self._closable

    def setClosable(self, closable):
        '''
        Sets the closable boolean attribute of the tab.
        '''
        self._closable = closable

    def update(self, result):
        '''
        Selects and updates status of a tree item corresponding to given result.
        '''
        log.debug("Selecting tree item for result '%s'" % result.id)
        item = self._getItem(result.id)
        self._setItemStatus(item)
        self._treeWidget.setCurrentItem(item)

    def refresh(self):
        '''
        Refreshes details of a test result that corresponds to the currently
        selected item.
        '''
        log.debug("Refreshing currently selected result item")
        item = self._treeWidget.currentItem()
        self._treeWidget.setCurrentItem(None)
        self._treeWidget.setCurrentItem(item)

    def expandItems(self):
        '''
        Expands tree items with statuses read from the settings option.
        '''
        items = self._treeWidget.findItems(
            "*", QtCore.Qt.MatchRecursive | QtCore.Qt.MatchWildcard)
        for item in items:
            item.setExpanded(False)
        self._treeWidget.setCurrentItem(None)
        QtGui.qApp.processEvents()
        statuses = map(lambda s: s.strip(), self._expandStatuses.getList())
        log.debug("Expanding items of results: %s" % ",".join(statuses))
        for item in items:
            if (item.testResult
                    and not isinstance(item.testResult, TestStepResult)
                    and item.testResult.status in statuses):
                item.setExpanded(True)
                parent = item.parent()
                while parent:
                    parent.setExpanded(True)
                    parent = parent.parent()

# Slots:
#@QtCore.Slot(QtGui.QTreeWidgetItem)

    def display(self, item):
        '''
        Displays details of given tree item.
        '''
        if self._view.isTabCurrent(self):
            if item is None or item.testResult is None:
                self._view.clearDetails()
            else:
                self._view.showDetails(item.testResult)

    #@QtCore.Slot()
    def expand(self):
        '''
        Expands the currently selected tree item.
        '''
        def expandRecursively(item):
            self._treeWidget.expandItem(item)
            for index in xrange(item.childCount()):
                expandRecursively(item.child(index))

        if self._view.isTabCurrent(self):
            log.debug("Expanding selected tree item")
            item = self._treeWidget.currentItem()
            if item:
                expandRecursively(item)

    #@QtCore.Slot()
    def expandAll(self):
        '''
        Expands all items in the tree.
        '''
        if self._view.isTabCurrent(self):
            log.debug("Expanding all tree items")
            self._treeWidget.expandAll()
            for i in xrange(self._COLUMN_COUNT):
                self._treeWidget.resizeColumnToContents(i)

    #@QtCore.Slot()
    def collapse(self):
        '''
        Collapses currently selected tree item.
        '''
        if self._view.isTabCurrent(self):
            log.debug("Collapsing selected tree item")
            self._treeWidget.collapseItem(self._treeWidget.currentItem())

    #@QtCore.Slot()
    def collapseAll(self):
        '''
        Collapses all items of tree.
        '''
        if self._view.isTabCurrent(self):
            log.debug("Collapsing all tree items")
            self._treeWidget.collapseAll()
            for i in xrange(self._COLUMN_COUNT):
                self._treeWidget.resizeColumnToContents(i)

    #@QtCore.Slot(QtGui.QTreeWidgetItem)
    def _updateOnExpand(self, item):
        '''
        Updates widths of columns in the tree to fit given tree item.
        '''
        if self._view.isTabCurrent(self):
            for i in xrange(self._COLUMN_COUNT):
                self._treeWidget.resizeColumnToContents(i)

    #@QtCore.Slot(QtGui.QTreeWidgetItem)
    def _updateOnCollapse(self, item):
        '''
        Clears result details in the Result view, sets the given item as
        current and updates widths of columns to fit it.
        '''
        if self._view.isTabCurrent(self):
            items = self._treeWidget.selectedItems()
            if items and items[0] is not item and items[0].parent():
                parent = items[0].parent()
                while True:
                    if parent is item:
                        self._view.clearDetails()
                        self._treeWidget.setCurrentItem(None)
                        break
                    if parent is None:
                        break
                    parent = parent.parent()
            for i in xrange(self._COLUMN_COUNT):
                self._treeWidget.resizeColumnToContents(i)
Esempio n. 46
0
 def configureChannel(self, name, clsname, **params):
     section = settings.get(channels.CONFIG_NAME, name, force=True)
     section["class"] = clsname
     for param, value in params.iteritems():
         section[param] = value
     self.configChannels.append(name)