spyder_unittest-0.1.2/0000755000175000017500000000000013056633151015240 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest.egg-info/0000755000175000017500000000000013056633151022177 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest.egg-info/top_level.txt0000644000175000017500000000002013056633151024721 0ustar jitsejitse00000000000000spyder_unittest spyder_unittest-0.1.2/spyder_unittest.egg-info/PKG-INFO0000644000175000017500000000253013056633151023274 0ustar jitsejitse00000000000000Metadata-Version: 1.1 Name: spyder-unittest Version: 0.1.2 Summary: Plugin to run tests from within the Spyder IDE Home-page: https://github.com/spyder-ide/spyder-unittest Author: Spyder Project Contributors Author-email: UNKNOWN License: MIT Description: This is a plugin for the Spyder IDE that integrates popular unit test frameworks. It allows you to run tests and view the results. **Status:** This is a work in progress. It is useable, but only the basic functionality is implemented at the moment. The plugin currently supports the py.test and nose testing frameworks. Keywords: Qt PyQt4 PyQt5 spyder plugins testing Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: X11 Applications :: Qt Classifier: Environment :: Win32 (MS Windows) Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Topic :: Software Development :: Testing Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) spyder_unittest-0.1.2/spyder_unittest.egg-info/dependency_links.txt0000644000175000017500000000000113056633151026245 0ustar jitsejitse00000000000000 spyder_unittest-0.1.2/spyder_unittest.egg-info/SOURCES.txt0000644000175000017500000000122413056633151024062 0ustar jitsejitse00000000000000CHANGELOG.md LICENSE.txt MANIFEST.in README.md setup.cfg setup.py spyder_unittest/__init__.py spyder_unittest/unittestplugin.py spyder_unittest.egg-info/PKG-INFO spyder_unittest.egg-info/SOURCES.txt spyder_unittest.egg-info/dependency_links.txt spyder_unittest.egg-info/requires.txt spyder_unittest.egg-info/top_level.txt spyder_unittest/backend/__init__.py spyder_unittest/backend/testrunner.py spyder_unittest/backend/tests/test_testrunner.py spyder_unittest/widgets/__init__.py spyder_unittest/widgets/configdialog.py spyder_unittest/widgets/unittestgui.py spyder_unittest/widgets/tests/test_configdialog.py spyder_unittest/widgets/tests/test_unittestgui.pyspyder_unittest-0.1.2/spyder_unittest.egg-info/requires.txt0000644000175000017500000000003313056633151024573 0ustar jitsejitse00000000000000lxml nose pytest spyder>=3 spyder_unittest-0.1.2/spyder_unittest/0000755000175000017500000000000013056633151020505 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest/widgets/0000755000175000017500000000000013056633151022153 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest/widgets/unittestgui.py0000644000175000017500000002761113047645510025122 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Unit Testing widget.""" from __future__ import with_statement # Standard library imports from collections import Counter import os.path as osp import sys # Third party imports from qtpy.QtCore import Qt, Signal from qtpy.QtGui import QBrush, QColor, QFont from qtpy.QtWidgets import (QHBoxLayout, QLabel, QMenu, QMessageBox, QToolButton, QTreeWidget, QTreeWidgetItem, QVBoxLayout, QWidget) from spyder.config.base import get_conf_path, get_translation from spyder.utils import icon_manager as ima from spyder.utils.qthelpers import create_action, create_toolbutton from spyder.widgets.variableexplorer.texteditor import TextEditor # Local imports from spyder_unittest.backend.testrunner import Category, TestRunner from spyder_unittest.widgets.configdialog import Config, ask_for_config # This is needed for testing this module as a stand alone script try: _ = get_translation("unittest", dirname="spyder_unittest") except KeyError as error: import gettext _ = gettext.gettext COL_POS = 0 # Position is not displayed but set as Qt.UserRole COLORS = { Category.OK: QBrush(QColor("#C1FFBA")), Category.FAIL: QBrush(QColor("#FF0000")), Category.SKIP: QBrush(QColor("#C5C5C5")) } def is_unittesting_installed(): """Check if the program and the library for line_profiler is installed.""" # return (programs.is_module_installed('line_profiler') # and programs.find_program('kernprof.py') is not None) return True class UnitTestWidget(QWidget): """ Unit testing widget. Attributes ---------- config : Config Configuration for running tests. default_wdir : str Default choice of working directory. pythonpath : list of str Directories to be added to the Python path when running tests. testrunner : TestRunner or None Object associated with the current test process, or `None` if no test process is running at the moment. Signals ------- sig_finished: Emitted when plugin finishes processing tests. """ VERSION = '0.0.1' sig_finished = Signal() def __init__(self, parent): """Unit testing widget.""" QWidget.__init__(self, parent) self.setWindowTitle("Unit testing") self.config = None self.pythonpath = None self.default_wdir = None self.testrunner = None self.output = None self.datatree = UnitTestDataTree(self) self.start_button = create_toolbutton(self, text_beside_icon=True) self.set_running_state(False) self.status_label = QLabel('', self) self.config_action = create_action( self, text=_("Configure ..."), icon=ima.icon('configure'), triggered=self.configure) self.log_action = create_action( self, text=_('Show output'), icon=ima.icon('log'), triggered=self.show_log) self.collapse_action = create_action( self, text=_('Collapse all'), icon=ima.icon('collapse'), triggered=self.datatree.collapseAll()) self.expand_action = create_action( self, text=_('Expand all'), icon=ima.icon('expand'), triggered=self.datatree.expandAll()) options_menu = QMenu() options_menu.addAction(self.config_action) options_menu.addAction(self.log_action) options_menu.addAction(self.collapse_action) options_menu.addAction(self.expand_action) self.options_button = QToolButton(self) self.options_button.setIcon(ima.icon('tooloptions')) self.options_button.setPopupMode(QToolButton.InstantPopup) self.options_button.setMenu(options_menu) self.options_button.setAutoRaise(True) hlayout = QHBoxLayout() hlayout.addWidget(self.start_button) hlayout.addStretch() hlayout.addWidget(self.status_label) hlayout.addStretch() hlayout.addWidget(self.options_button) layout = QVBoxLayout() layout.addLayout(hlayout) layout.addWidget(self.datatree) self.setLayout(layout) if not is_unittesting_installed(): for widget in (self.datatree, self.log_action, self.start_button, self.collapse_action, self.expand_action): widget.setDisabled(True) else: pass # self.show_data() def show_log(self): """Show output of testing process.""" if self.output: TextEditor( self.output, title=_("Unit testing output"), readonly=True, size=(700, 500)).exec_() def configure(self): """Configure tests.""" if self.config: oldconfig = self.config else: oldconfig = Config(wdir=self.default_wdir) config = ask_for_config(oldconfig) if config: self.config = config def config_is_valid(self): """Return whether configuration for running tests is valid.""" return (self.config and self.config.framework and osp.isdir(self.config.wdir)) def maybe_configure_and_start(self): """ Ask for configuration if necessary and then run tests. If the current test configuration is not valid (or not set(, then ask the user to configure. Then run the tests. """ if not self.config_is_valid(): self.configure() if self.config_is_valid(): self.run_tests() def run_tests(self, config=None): """ Run unit tests. The process's output is consumed by `read_output()`. When the process finishes, the `finish` signal is emitted. Parameters ---------- config : Config or None configuration for unit tests. If None, use `self.config`. In either case, configuration should be valid. """ if config is None: config = self.config pythonpath = self.pythonpath self.datatree.clear() tempfilename = get_conf_path('unittest.results') self.testrunner = TestRunner(self, tempfilename) self.testrunner.sig_finished.connect(self.process_finished) try: self.testrunner.start(config, pythonpath) except RuntimeError: QMessageBox.critical(self, _("Error"), _("Process failed to start")) else: self.set_running_state(True) self.status_label.setText(_('Running tests ...')) def set_running_state(self, state): """ Change start/kill button according to whether tests are running. If tests are running, then display a kill button, otherwise display a start button. Parameters ---------- state : bool Set to True if tests are running. """ button = self.start_button try: button.clicked.disconnect() except TypeError: # raised if not connected to any handler pass if state: button.setIcon(ima.icon('stop')) button.setText(_('Kill')) button.setToolTip(_('Kill current test process')) if self.testrunner: button.clicked.connect(self.testrunner.kill_if_running) else: button.setIcon(ima.icon('run')) button.setText(_("Run tests")) button.setToolTip(_('Run unit tests')) button.clicked.connect( lambda checked: self.maybe_configure_and_start()) def process_finished(self, testresults, output): """ Called when unit test process finished. This function collects and shows the test results and output. """ self.output = output self.set_running_state(False) self.testrunner = None self.log_action.setEnabled(bool(output)) self.datatree.testresults = testresults msg = self.datatree.show_tree() self.status_label.setText(msg) self.sig_finished.emit() class UnitTestDataTree(QTreeWidget): """Convenience tree widget to store and view unit testing data.""" def __init__(self, parent=None): """Convenience tree widget to store and view unit testing data.""" QTreeWidget.__init__(self, parent) self.header_list = [ _('Status'), _('Name'), _('Message'), _('Time (ms)') ] self.testresults = [] self.header().setDefaultAlignment(Qt.AlignCenter) self.setColumnCount(len(self.header_list)) self.setHeaderLabels(self.header_list) self.clear() self.setItemsExpandable(True) self.setSortingEnabled(False) def show_tree(self): """Populate the tree with unit testing data and display it.""" self.clear() # Clear before re-populating msg = self.populate_tree() for col in range(self.columnCount() - 1): self.resizeColumnToContents(col) return msg def populate_tree(self): """Create each item (and associated data) in the tree.""" if not len(self.testresults): return _('No results to show.') try: monospace_font = self.window().editor.get_plugin_font() except AttributeError: # If run standalone for testing monospace_font = QFont("Courier New") monospace_font.setPointSize(10) for testresult in self.testresults: testcase_item = QTreeWidgetItem(self) testcase_item.setData(0, Qt.DisplayRole, testresult.status) testcase_item.setData(1, Qt.DisplayRole, testresult.name) testcase_item.setData(2, Qt.DisplayRole, testresult.message) testcase_item.setData(3, Qt.DisplayRole, testresult.time * 1e3) color = COLORS[testresult.category] for col in range(self.columnCount()): testcase_item.setBackground(col, color) if testresult.extra_text: for line in testresult.extra_text.rstrip().split("\n"): error_content_item = QTreeWidgetItem(testcase_item) error_content_item.setData(0, Qt.DisplayRole, line) error_content_item.setFirstColumnSpanned(True) error_content_item.setFont(0, monospace_font) counts = Counter(res.category for res in self.testresults) if counts[Category.FAIL] == 1: test_or_tests = _('test') else: test_or_tests = _('tests') failed_txt = '{} {} failed'.format(counts[Category.FAIL], test_or_tests) passed_txt = '{} passed'.format(counts[Category.OK]) other_txt = '{} other'.format(counts[Category.SKIP]) msg = '{}, {}, {}'.format(failed_txt, passed_txt, other_txt) return msg def item_activated(self, item): """Called if user clicks on item.""" filename, line_no = item.data(COL_POS, Qt.UserRole) self.parent().edit_goto.emit(filename, line_no, '') def test(): """ Run widget test. Show the unittest widgets, configured so that our own tests are run when the user clicks "Run tests". """ from spyder.utils.qthelpers import qapplication app = qapplication() widget = UnitTestWidget(None) # set wdir to .../spyder_unittest wdir = osp.abspath(osp.join(osp.dirname(__file__), osp.pardir)) widget.config = Config('py.test', wdir) # add wdir's parent to python path, so that `import spyder_unittest` works rootdir = osp.abspath(osp.join(wdir, osp.pardir)) widget.pythonpath = rootdir widget.resize(800, 600) widget.show() sys.exit(app.exec_()) if __name__ == '__main__': test() spyder_unittest-0.1.2/spyder_unittest/widgets/tests/0000755000175000017500000000000013056633151023315 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest/widgets/tests/test_configdialog.py0000644000175000017500000000443513047645510027363 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Tests for configdialog.py.""" # Standard library imports import os # Third party imports from qtpy.QtWidgets import QDialogButtonBox # Local imports from spyder_unittest.widgets.configdialog import Config, ConfigDialog def default_config(): return Config(framework=None, wdir=os.getcwd()) def test_configdialog_sets_initial_config(qtbot): config = default_config() configdialog = ConfigDialog(config) assert configdialog.get_config() == config def test_configdialog_click_pytest(qtbot): configdialog = ConfigDialog(default_config()) qtbot.addWidget(configdialog) configdialog.pytest_button.click() assert configdialog.get_config().framework == 'py.test' def test_configdialog_ok_initially_disabled(qtbot): configdialog = ConfigDialog(default_config()) qtbot.addWidget(configdialog) assert not configdialog.buttons.button(QDialogButtonBox.Ok).isEnabled() def test_configdialog_ok_setting_framework_initially_enables_ok(qtbot): config = Config(framework='py.test', wdir=os.getcwd()) configdialog = ConfigDialog(config) qtbot.addWidget(configdialog) assert configdialog.buttons.button(QDialogButtonBox.Ok).isEnabled() def test_configdialog_clicking_pytest_enables_ok(qtbot): configdialog = ConfigDialog(default_config()) qtbot.addWidget(configdialog) configdialog.pytest_button.click() assert configdialog.buttons.button(QDialogButtonBox.Ok).isEnabled() def test_configdialog_wdir_lineedit(qtbot): configdialog = ConfigDialog(default_config()) qtbot.addWidget(configdialog) wdir = os.path.normpath(os.path.join(os.getcwd(), os.path.pardir)) configdialog.wdir_lineedit.setText(wdir) assert configdialog.get_config().wdir == wdir def test_configdialog_wdir_button(qtbot, monkeypatch): configdialog = ConfigDialog(default_config()) qtbot.addWidget(configdialog) wdir = os.path.normpath(os.path.join(os.getcwd(), os.path.pardir)) monkeypatch.setattr( 'spyder_unittest.widgets.configdialog.getexistingdirectory', lambda parent, caption, basedir: wdir) configdialog.wdir_button.click() assert configdialog.get_config().wdir == wdir spyder_unittest-0.1.2/spyder_unittest/widgets/tests/test_unittestgui.py0000644000175000017500000000340213047645510027313 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Tests for unittestgui.py.""" # Standard library imports import os # Third party imports from pytestqt import qtbot from qtpy.QtCore import Qt import pytest # Local imports from spyder_unittest.widgets.configdialog import Config from spyder_unittest.widgets.unittestgui import UnitTestWidget try: from unittest.mock import Mock except ImportError: from mock import Mock # Python 2 @pytest.mark.parametrize('framework', ['py.test', 'nose']) def test_run_tests_and_display_results(qtbot, tmpdir, monkeypatch, framework): """Basic check.""" os.chdir(tmpdir.strpath) testfilename = tmpdir.join('test_foo.py').strpath with open(testfilename, 'w') as f: f.write("def test_ok(): assert 1+1 == 2\n" "def test_fail(): assert 1+1 == 3\n") MockQMessageBox = Mock() monkeypatch.setattr('spyder_unittest.widgets.unittestgui.QMessageBox', MockQMessageBox) widget = UnitTestWidget(None) qtbot.addWidget(widget) config = Config(wdir=tmpdir.strpath, framework=framework) with qtbot.waitSignal(widget.sig_finished, timeout=10000, raising=True): widget.run_tests(config) MockQMessageBox.assert_not_called() dt = widget.datatree itemcount = dt.topLevelItemCount() assert itemcount == 2 assert dt.topLevelItem(0).data(0, Qt.DisplayRole) == 'ok' assert dt.topLevelItem(0).data(1, Qt.DisplayRole) == 'test_foo.test_ok' assert dt.topLevelItem(0).data(2, Qt.DisplayRole) == '' assert dt.topLevelItem(1).data(0, Qt.DisplayRole) == 'failure' assert dt.topLevelItem(1).data(1, Qt.DisplayRole) == 'test_foo.test_fail' spyder_unittest-0.1.2/spyder_unittest/widgets/__init__.py0000644000175000017500000000027313047645510024270 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Widgets for unittest plugin.""" spyder_unittest-0.1.2/spyder_unittest/widgets/configdialog.py0000644000175000017500000001151113047645510025153 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """ Functionality for asking the user to specify the test configuration. The main entry point is `ask_for_config()`. """ # Standard library imports from collections import namedtuple import os.path as osp # Third party imports from qtpy.compat import getexistingdirectory from qtpy.QtWidgets import (QApplication, QDialog, QDialogButtonBox, QGroupBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QRadioButton, QVBoxLayout) from spyder.config.base import get_translation from spyder.py3compat import getcwd, to_text_string from spyder.utils import icon_manager as ima try: _ = get_translation("unittest", dirname="spyder_unittest") except KeyError as error: import gettext _ = gettext.gettext Config = namedtuple('Config', ['framework', 'wdir']) Config.__new__.__defaults__ = (None, '') class ConfigDialog(QDialog): """ Dialog window for specifying test configuration. The window contains two radio buttons (for 'py,test' and 'nose'), a line edit box for specifying the working directory, a button to use a file browser for selecting the directory, and OK and Cancel buttons. Initially, neither radio button is selected and the OK button is disabled. Selecting a radio button enabled the OK button. """ def __init__(self, config, parent=None): """ Construct a dialog window. Parameters ---------- config : Config Initial configuration parent : QWidget """ super(ConfigDialog, self).__init__(parent) self.setWindowTitle(_('Configure tests')) layout = QVBoxLayout(self) framework_groupbox = QGroupBox(_('Test framework'), self) framework_layout = QVBoxLayout(framework_groupbox) self.pytest_button = QRadioButton('py.test', framework_groupbox) framework_layout.addWidget(self.pytest_button) self.nose_button = QRadioButton('nose', framework_groupbox) framework_layout.addWidget(self.nose_button) layout.addWidget(framework_groupbox) layout.addSpacing(10) wdir_label = QLabel(_('Directory from which to run tests')) layout.addWidget(wdir_label) wdir_layout = QHBoxLayout() self.wdir_lineedit = QLineEdit(self) wdir_layout.addWidget(self.wdir_lineedit) self.wdir_button = QPushButton(ima.icon('DirOpenIcon'), '', self) self.wdir_button.setToolTip(_("Select directory")) self.wdir_button.clicked.connect(lambda: self.select_directory()) wdir_layout.addWidget(self.wdir_button) layout.addLayout(wdir_layout) layout.addSpacing(20) self.buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) layout.addWidget(self.buttons) self.buttons.accepted.connect(self.accept) self.buttons.rejected.connect(self.reject) ok_button = self.buttons.button(QDialogButtonBox.Ok) ok_button.setEnabled(False) self.pytest_button.toggled.connect(lambda: ok_button.setEnabled(True)) self.nose_button.toggled.connect(lambda: ok_button.setEnabled(True)) if config.framework == 'py.test': self.pytest_button.setChecked(True) elif config.framework == 'nose': self.nose_button.setChecked(True) self.wdir_lineedit.setText(config.wdir) def select_directory(self): """Display dialog for user to select working directory.""" basedir = to_text_string(self.wdir_lineedit.text()) if not osp.isdir(basedir): basedir = getcwd() title = _("Select directory") directory = getexistingdirectory(self, title, basedir) if directory: self.wdir_lineedit.setText(directory) def get_config(self): """ Return the test configuration specified by the user. Returns ------- Config Test configuration """ if self.pytest_button.isChecked(): framework = 'py.test' elif self.nose_button.isChecked(): framework = 'nose' else: framework = None return Config(framework=framework, wdir=self.wdir_lineedit.text()) def ask_for_config(config, parent=None): """ Ask user to specify a test configuration. This is a convenience function which displays a modal dialog window of type `ConfigDialog`. """ dialog = ConfigDialog(config, parent) result = dialog.exec_() if result == QDialog.Accepted: return dialog.get_config() if __name__ == '__main__': app = QApplication([]) config = Config(framework=None, wdir=getcwd()) print(ask_for_config(config)) spyder_unittest-0.1.2/spyder_unittest/backend/0000755000175000017500000000000013056633151022074 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest/backend/testrunner.py0000644000175000017500000001616613047645510024673 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Classes for running tests within various frameworks.""" # Standard library imports from collections import namedtuple import os import tempfile # Third party imports from lxml import etree from qtpy.QtCore import (QObject, QProcess, QProcessEnvironment, QTextCodec, Signal) from spyder.config.base import get_translation from spyder.py3compat import to_text_string from spyder.utils.misc import add_pathlist_to_PYTHONPATH try: _ = get_translation("unittest", dirname="spyder_unittest") except KeyError as error: import gettext _ = gettext.gettext # Class representing test results TestResult = namedtuple('TestResult', [ 'category', 'status', 'name', 'message', 'time', 'extra_text' ]) class Category: """Enum type representing category of test result.""" OK = 1 FAIL = 2 SKIP = 3 class TestRunner(QObject): """ Class for running tests with py.test or nose. All communication back to the caller is done via signals. Attributes ---------- process : QProcess or None Process running the unit test suite. resultfilename : str Name of file in which test results are stored. Signals ------- sig_finished(list of TestResult, str) Emitted when test process finishes. First argument contains the test results, second argument contains the output of the test process. """ sig_finished = Signal(object, str) def __init__(self, widget, resultfilename=None): """ Construct test runner. Parameters ---------- widget : UnitTestWidget Unit test widget which constructs the test runner. resultfilename : str or None Name of file in which to store test results. If None, use default. """ QObject.__init__(self, widget) self.process = None if resultfilename is None: self.resultfilename = os.path.join(tempfile.gettempdir(), 'unittest.results') else: self.resultfilename = resultfilename def start(self, config, pythonpath): """ Start process which will run the unit test suite. The process is run in the working directory specified in 'config', with the directories in `pythonpath` added to the Python path for the test process. The test results are written to the file `self.resultfilename`. The standard output and error are also recorded. Once the process is finished, `self.finished()` will be called. Parameters ---------- config : TestConfig Unit test configuration. pythonpath : list of str List of directories to be added to the Python path Raises ------ RuntimeError If process failed to start. """ framework = config.framework wdir = config.wdir self.process = QProcess(self) self.process.setProcessChannelMode(QProcess.MergedChannels) self.process.setWorkingDirectory(wdir) self.process.finished.connect(self.finished) if pythonpath is not None: env = [ to_text_string(_pth) for _pth in self.process.systemEnvironment() ] add_pathlist_to_PYTHONPATH(env, pythonpath) processEnvironment = QProcessEnvironment() for envItem in env: envName, separator, envValue = envItem.partition('=') processEnvironment.insert(envName, envValue) self.process.setProcessEnvironment(processEnvironment) if framework == 'nose': executable = 'nosetests' p_args = [ '--with-xunit', '--xunit-file={}'.format(self.resultfilename) ] elif framework == 'py.test': executable = 'py.test' p_args = ['--junit-xml', self.resultfilename] else: raise ValueError('Unknown framework') if os.name == 'nt': executable += '.exe' try: os.remove(self.resultfilename) except OSError: pass self.process.start(executable, p_args) running = self.process.waitForStarted() if not running: raise RuntimeError def finished(self): """ Called when the unit test process has finished. This function reads the results and emits `sig_finished`. """ qbytearray = self.process.readAllStandardOutput() locale_codec = QTextCodec.codecForLocale() output = to_text_string(locale_codec.toUnicode(qbytearray.data())) testresults = self.load_data() self.sig_finished.emit(testresults, output) def kill_if_running(self): """Kill testing process if it is running.""" if self.process and self.process.state() == QProcess.Running: self.process.kill() def load_data(self): """ Read and parse unit test results. This function reads the unit test results from the file with name `self.resultfilename` and parses them. The file should contain the test results in JUnitXML format. Returns ------- list of TestResult Unit test results. """ try: data = etree.parse(self.resultfilename).getroot() except OSError: data = [] testresults = [] for testcase in data: category = Category.OK status = 'ok' name = '{0}.{1}'.format( testcase.get('classname'), testcase.get('name')) message = '' time = float(testcase.get('time')) extras = [] for child in testcase: if child.tag in ('error', 'failure', 'skipped'): if child.tag == 'skipped': category = Category.SKIP else: category = Category.FAIL status = child.tag type_ = child.get('type') message = child.get('message', default='') if type_ and message: message = '{0}: {1}'.format(type_, message) elif type_: message = type_ if child.text: extras.append(child.text) elif child.tag in ('system-out', 'system-err'): if child.tag == 'system-out': heading = _('Captured stdout') else: heading = _('Captured stderr') contents = child.text.rstrip('\n') extras.append('----- {} -----\n{}'.format(heading, contents)) extra_text = '\n\n'.join(extras) testresults.append( TestResult(category, status, name, message, time, extra_text)) return testresults spyder_unittest-0.1.2/spyder_unittest/backend/tests/0000755000175000017500000000000013056633151023236 5ustar jitsejitse00000000000000spyder_unittest-0.1.2/spyder_unittest/backend/tests/test_testrunner.py0000644000175000017500000001115213047645510027062 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Tests for testrunner.py""" # Standard library imports import os # Local imports from spyder_unittest.backend.testrunner import Category, TestRunner from spyder_unittest.widgets.configdialog import Config try: from unittest.mock import Mock except ImportError: from mock import Mock # Python 2 def test_testrunner_start(monkeypatch): MockQProcess = Mock() monkeypatch.setattr('spyder_unittest.backend.testrunner.QProcess', MockQProcess) mock_process = MockQProcess() mock_process.systemEnvironment = lambda: ['VAR=VALUE', 'PYTHONPATH=old'] MockEnvironment = Mock() monkeypatch.setattr( 'spyder_unittest.backend.testrunner.QProcessEnvironment', MockEnvironment) mock_environment = MockEnvironment() mock_remove = Mock(side_effect=OSError()) monkeypatch.setattr('spyder_unittest.backend.testrunner.os.remove', mock_remove) runner = TestRunner(None, 'results') config = Config('py.test', 'wdir') runner.start(config, ['pythondir']) mock_process.setWorkingDirectory.assert_called_once_with('wdir') mock_process.finished.connect.assert_called_once_with(runner.finished) mock_process.setProcessEnvironment.assert_called_once_with( mock_environment) executable_name = 'py.test.exe' if os.name == 'nt' else 'py.test' mock_process.start.assert_called_once_with(executable_name, ['--junit-xml', 'results']) mock_environment.insert.assert_any_call('VAR', 'VALUE') # mock_environment.insert.assert_any_call('PYTHONPATH', 'pythondir:old') # TODO: Find out why above test fails mock_remove.called_once_with('results') def test_testrunner_load_data(tmpdir): result_file = tmpdir.join('results') result_txt = """ text text2 """ result_file.write(result_txt) runner = TestRunner(None, result_file.strpath) results = runner.load_data() assert len(results) == 3 assert results[0].category == Category.OK assert results[0].status == 'ok' assert results[0].name == 'test_foo.test1' assert results[0].message == '' assert results[0].time == 0.04 assert results[0].extra_text == '' assert results[1].category == Category.FAIL assert results[1].status == 'failure' assert results[1].name == 'test_foo.test2' assert results[1].message == 'failure message' assert results[1].time == 0.01 assert results[1].extra_text == 'text' assert results[2].category == Category.SKIP assert results[2].status == 'skipped' assert results[2].name == 'test_foo.test3' assert results[2].message == 'skip message' assert results[2].time == 0.05 assert results[2].extra_text == 'text2' def test_testrunner_load_data_failing_test_with_stdout(tmpdir): result_file = tmpdir.join('results') result_txt = """ text stdout text """ result_file.write(result_txt) runner = TestRunner(None, result_file.strpath) results = runner.load_data() assert results[0].extra_text == ( 'text\n\n' + '----- Captured stdout -----\n' + 'stdout text') def test_testrunner_load_data_passing_test_with_stdout(tmpdir): result_file = tmpdir.join('results') result_txt = """ stdout text """ result_file.write(result_txt) runner = TestRunner(None, result_file.strpath) results = runner.load_data() assert results[0].extra_text == ( '----- Captured stdout -----\n' + 'stdout text') spyder_unittest-0.1.2/spyder_unittest/backend/__init__.py0000644000175000017500000000033413047645510024207 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Parts of the unittest plugin that are not related to the GUI.""" spyder_unittest-0.1.2/spyder_unittest/__init__.py0000644000175000017500000000044513056633121022616 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Spyder unitest plugin.""" # Local imports from .unittestplugin import UnitTestPlugin as PLUGIN_CLASS __version__ = '0.1.2' PLUGIN_CLASS spyder_unittest-0.1.2/spyder_unittest/unittestplugin.py0000644000175000017500000001146513047645510024166 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """Unit testing Plugin.""" # Third party imports from qtpy.QtWidgets import QVBoxLayout from spyder.config.base import get_translation from spyder.plugins import SpyderPluginWidget from spyder.py3compat import getcwd from spyder.utils import icon_manager as ima from spyder.utils.qthelpers import create_action # Local imports from .widgets.unittestgui import UnitTestWidget, is_unittesting_installed _ = get_translation("unittest", dirname="spyder_unittest") class UnitTestPlugin(SpyderPluginWidget): """Spyder plugin for unit testing.""" CONF_SECTION = 'unittest' def __init__(self, parent=None): """Initialize plugin and corresponding widget.""" SpyderPluginWidget.__init__(self, parent) self.main = parent # Spyder 3 compatibility # Create unit test widget self.unittestwidget = UnitTestWidget(self.main) self.update_pythonpath() self.update_default_wdir() # Connect to relevant signals self.main.sig_pythonpath_changed.connect(self.update_pythonpath) self.main.workingdirectory.set_explorer_cwd.connect( self.update_default_wdir) self.main.projects.sig_project_created.connect( self.update_default_wdir) self.main.projects.sig_project_loaded.connect(self.update_default_wdir) self.main.projects.sig_project_closed.connect(self.update_default_wdir) # Add unit test widget in dockwindow layout = QVBoxLayout() layout.addWidget(self.unittestwidget) self.setLayout(layout) # Initialize plugin self.initialize_plugin() def update_pythonpath(self): """ Update Python path used to run unit tests. This function is called whenever the Python path set in Spyder changes. It synchronizes the Python path in the unittest widget with the Python path in Spyder. """ self.unittestwidget.pythonpath = self.main.get_spyder_pythonpath() def update_default_wdir(self): """ Update default working dir for running unit tests. The default working dir for running unit tests is set to the project directory if a project is open, or the current working directory if no project is opened. This function is called whenever this directory may change. """ wdir = self.main.projects.get_active_project_path() if not wdir: # if no project opened wdir = getcwd() self.unittestwidget.default_wdir = wdir # ----- SpyderPluginWidget API -------------------------------------------- def get_plugin_title(self): """Return widget title.""" return _("Unit testing") def get_plugin_icon(self): """Return widget icon.""" return ima.icon('profiler') def get_focus_widget(self): """Return the widget to give focus to this dockwidget when raised.""" return self.unittestwidget.datatree def get_plugin_actions(self): """Return a list of actions related to plugin.""" return [] def on_first_registration(self): """Action to be performed on first plugin registration.""" self.main.tabify_plugins(self.main.help, self) self.dockwidget.hide() def register_plugin(self): """Register plugin in Spyder's main window.""" self.main.add_dockwidget(self) unittesting_act = create_action( self, _("Run unit tests"), icon=ima.icon('profiler'), shortcut="Shift+Alt+F11", triggered=self.maybe_configure_and_start) unittesting_act.setEnabled(is_unittesting_installed()) self.main.run_menu_actions += [unittesting_act] self.main.editor.pythonfile_dependent_actions += [unittesting_act] def refresh_plugin(self): """Refresh unit testing widget.""" pass def closing_plugin(self, cancelable=False): """Perform actions before parent main window is closed.""" return True def apply_plugin_settings(self, options): """Apply configuration file's plugin settings.""" pass # ----- Public API -------------------------------------------------------- def maybe_configure_and_start(self): """ Ask for configuration if necessary and then run tests. Raise unittest widget. If the current test configuration is not valid (or not set), then ask the user to configure. Then run the tests. """ if self.dockwidget and not self.ismaximized: self.dockwidget.setVisible(True) self.dockwidget.setFocus() self.dockwidget.raise_() self.unittestwidget.maybe_configure_and_start() spyder_unittest-0.1.2/LICENSE.txt0000644000175000017500000000210513047645510017063 0ustar jitsejitse00000000000000The MIT License (MIT) Copyright © 2013 Spyder Project Contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. spyder_unittest-0.1.2/setup.py0000644000175000017500000000542013054401543016747 0ustar jitsejitse00000000000000# -*- coding: utf-8 -*- # # Copyright © 2013 Spyder Project Contributors # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """ Setup script for spyder_unittest """ from setuptools import setup, find_packages import os import os.path as osp def get_version(): """Get version from source file""" import codecs with codecs.open("spyder_unittest/__init__.py", encoding="utf-8") as f: lines = f.read().splitlines() for l in lines: if "__version__" in l: version = l.split("=")[1].strip() version = version.replace("'", '').replace('"', '') return version def get_package_data(name, extlist): """Return data files for package *name* with extensions in *extlist*""" flist = [] # Workaround to replace os.path.relpath (not available until Python 2.6): offset = len(name) + len(os.pathsep) for dirpath, _dirnames, filenames in os.walk(name): for fname in filenames: if not fname.startswith('.') and osp.splitext(fname)[1] in extlist: flist.append(osp.join(dirpath, fname)[offset:]) return flist # Requirements REQUIREMENTS = ['lxml', 'nose', 'pytest', 'spyder>=3'] EXTLIST = ['.jpg', '.png', '.json', '.mo', '.ini'] LIBNAME = 'spyder_unittest' LONG_DESCRIPTION = """ This is a plugin for the Spyder IDE that integrates popular unit test frameworks. It allows you to run tests and view the results. **Status:** This is a work in progress. It is useable, but only the basic functionality is implemented at the moment. The plugin currently supports the py.test and nose testing frameworks. """ setup( name=LIBNAME, version=get_version(), packages=find_packages(exclude=['contrib', 'docs', 'tests*']), package_data={LIBNAME: get_package_data(LIBNAME, EXTLIST)}, keywords=["Qt PyQt4 PyQt5 spyder plugins testing"], install_requires=REQUIREMENTS, url='https://github.com/spyder-ide/spyder-unittest', license='MIT', author="Spyder Project Contributors", description='Plugin to run tests from within the Spyder IDE', long_description=LONG_DESCRIPTION, classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: X11 Applications :: Qt', 'Environment :: Win32 (MS Windows)', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Operating System :: OS Independent', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.5', 'Programming Language :: Python :: 3.6', 'Topic :: Software Development :: Testing', 'Topic :: Text Editors :: Integrated Development Environments (IDE)']) spyder_unittest-0.1.2/setup.cfg0000644000175000017500000000013013056633151017053 0ustar jitsejitse00000000000000[bdist_wheel] universal = 1 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 spyder_unittest-0.1.2/README.md0000644000175000017500000000660213047645510016525 0ustar jitsejitse00000000000000# spyder-unittest ## Project information [![license](https://img.shields.io/pypi/l/spyder-unittest.svg)](./LICENSE) [![pypi version](https://img.shields.io/pypi/v/spyder-unittest.svg)](https://pypi.python.org/pypi/spyder-unittest) [![Join the chat at https://gitter.im/spyder-ide/public](https://badges.gitter.im/spyder-ide/spyder.svg)](https://gitter.im/spyder-ide/public) ## Build status [![Build Status](https://travis-ci.org/spyder-ide/spyder-unittest.svg?branch=master)](https://travis-ci.org/spyder-ide/spyder-unittest) [![Build status](https://ci.appveyor.com/api/projects/status/d9wa6whp1fpq4uii?svg=true)](https://ci.appveyor.com/project/spyder-ide/spyder-unittest) [![CircleCI](https://circleci.com/gh/spyder-ide/spyder-unittest/tree/master.svg?style=shield)](https://circleci.com/gh/spyder-ide/spyder-unittest/tree/master) [![Coverage Status](https://coveralls.io/repos/github/spyder-ide/spyder-unittest/badge.svg?branch=master)](https://coveralls.io/github/spyder-ide/spyder-unittest?branch=master) [![Code Issues](https://www.quantifiedcode.com/api/v1/project/cce1ea0d121246ff876d2822e9e3d2a1/badge.svg)](https://www.quantifiedcode.com/app/project/cce1ea0d121246ff876d2822e9e3d2a1) [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/spyder-ide/spyder-unittest/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/spyder-ide/spyder-unittest/?branch=master) ## Description ![screenshot](./screenshot.png) This is a plugin for Spyder that integrates popular unit test frameworks. It allows you to run tests and view the results. ## Status This is a work in progress. It is useable, but only the basic functionality is implemented at the moment. The plugin supports the py.test and nose testing frameworks. ## Installation The unittest plugin is available in the `spyder-ide` channel in Anaconda and in PyPI, so it can be installed with the following commands: * Using Anaconda: `conda install -c spyder-ide spyder-unittest` * Using pip: `pip install spyder-unittest` All dependencies will be automatically installed. You have to restart Spyder before you can use the plugin. ## Usage The plugin adds an item `Run unit tests` to the `Run` menu in Spyder. Click on this to run the unit tests. After you specify the testing framework and the directory under which the tests are stored, the tests are run. The `Unit testing` window pane (displayed at the top of this file) will pop up with the results. If you want to run tests in a different directory or switch testing frameworks, click `Configure` in the Options menu (cogwheel icon), which is located in the upper right corner of the `Unit testing` pane. ## Development Development of the plugin is done at https://github.com/spyder-ide/spyder-unittest . You can install the development version of the plugin by cloning the git repository and running `pip install .`, possibly with the `--editable` flag. The plugin has the following dependencies: * [spyder](https://github.com/spyder-ide/spyder) (obviously), at least version 3.0 * [lxml](http://lxml.de/) * the testing framework that you will be using: [py.test](https://pytest.org) and/or [nose](https://nose.readthedocs.io) In order to run the tests distributed with this plugin, you need [nose](https://nose.readthedocs.io), [py.test](https://pytest.org) and [pytest-qt](https://github.com/pytest-dev/pytest-qt). If you use Python 2, you also need [mock](https://github.com/testing-cabal/mock). spyder_unittest-0.1.2/PKG-INFO0000644000175000017500000000253013056633151016335 0ustar jitsejitse00000000000000Metadata-Version: 1.1 Name: spyder_unittest Version: 0.1.2 Summary: Plugin to run tests from within the Spyder IDE Home-page: https://github.com/spyder-ide/spyder-unittest Author: Spyder Project Contributors Author-email: UNKNOWN License: MIT Description: This is a plugin for the Spyder IDE that integrates popular unit test frameworks. It allows you to run tests and view the results. **Status:** This is a work in progress. It is useable, but only the basic functionality is implemented at the moment. The plugin currently supports the py.test and nose testing frameworks. Keywords: Qt PyQt4 PyQt5 spyder plugins testing Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Environment :: X11 Applications :: Qt Classifier: Environment :: Win32 (MS Windows) Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python :: 2 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.5 Classifier: Programming Language :: Python :: 3.6 Classifier: Topic :: Software Development :: Testing Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) spyder_unittest-0.1.2/MANIFEST.in0000644000175000017500000000014213047650733017000 0ustar jitsejitse00000000000000include CHANGELOG.md include LICENSE.txt include README.md recursive-include spyder_unittest *.py spyder_unittest-0.1.2/CHANGELOG.md0000644000175000017500000000140213047645510017050 0ustar jitsejitse00000000000000# History of changes ## Version 0.1.1 (2017/02/11) This version improves the packaging. The code itself was not changed. ### Issues Closed * [Issue 58](https://github.com/spyder-ide/spyder-unittest/issues/58) - Normalized copyright information * [Issue 57](https://github.com/spyder-ide/spyder-unittest/issues/57) - Depend on nose and pytest at installation * [Issue 56](https://github.com/spyder-ide/spyder-unittest/issues/56) - Add the test suite to the release tarball In this release 3 issues were closed. ### Pull Requests Merged * [PR 59](https://github.com/spyder-ide/spyder-unittest/pull/59) - Improve distributed package In this release 1 pull request was closed. ## Version 0.1.0 (2017/02/05) Initial release, supporting nose and py.test frameworks.