def test_options_widget(self): w = textimport.CSVOptionsWidget() schanged = QSignalSpy(w.optionsChanged) sedited = QSignalSpy(w.optionsEdited) w.setDialect(csv.excel()) self.assertEqual(len(schanged), 1) self.assertEqual(len(sedited), 0) w.setSelectedEncoding("iso8859-1") self.assertEqual(len(schanged), 2) self.assertEqual(len(sedited), 0) d = w.dialect() self.assertEqual(d.delimiter, csv.excel.delimiter) self.assertEqual(d.doublequote, csv.excel.doublequote) self.assertEqual(w.encoding(), "iso8859-1") d = textimport.Dialect("a", "b", "c", True, True) w.setDialect(d) cb = w.findChild(QComboBox, "delimiter-combo-box") self.assertEqual(cb.currentIndex(), textimport.CSVOptionsWidget.DelimiterOther) le = w.findChild(QWidget, "custom-delimiter-edit") self.assertEqual(le.text(), "a") cb = w.findChild(QWidget, "quote-edit-combo-box") self.assertEqual(cb.currentText(), "b") d1 = w.dialect() self.assertEqual(d.delimiter, d1.delimiter) self.assertEqual(d.quotechar, d1.quotechar)
def wait_for_completion(self, manager): spy = QSignalSpy(manager.allDownloaded) self.assertTrue(spy.isValid()) manager.start() received = spy.wait(timeout=500) self.assertTrue(received)
def wait_for(self, timeout=None, *, override_waited_for=False, do_skip=False, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Args: timeout: How long to wait for the message. override_waited_for: If set, gets triggered by previous messages again. do_skip: If set, call pytest.skip on a timeout. Return: The matched line. """ __tracebackhide__ = True if timeout is None: if do_skip: timeout = 2000 elif 'CI' in os.environ: timeout = 15000 else: timeout = 5000 if not kwargs: raise TypeError("No keyword arguments given!") for key in kwargs: assert key in self.KEYS # Search existing messages existing = self._wait_for_existing(override_waited_for, **kwargs) if existing is not None: return existing # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: return match
def testReset(self): widget = self._widget table = widget._table spy = QSignalSpy(widget.load_metadata_sgn) spy_count = 0 cfg = ["efg", "2020-03-03 03:03:03", "efg setup"] widget._insertSetupToList(cfg) for row in range(2): for i in range(2): table.itemDoubleClicked.emit(table.item(row, i)) widget._meta.load_snapshot.assert_called_with( table.item(row, i).text()) widget._meta.load_snapshot.reset_mock() spy_count += 1 self.assertEqual(spy_count, len(spy)) table.itemDoubleClicked.emit(table.item(row, 2)) widget._meta.load_snapshot.assert_not_called() self.assertEqual(spy_count, len(spy)) # test reset spy = QSignalSpy(widget.load_metadata_sgn) widget._reset_btn.clicked.emit() widget._meta.load_snapshot.assert_called_with(widget.DEFAULT) self.assertEqual(1, len(spy))
def test_finished_state(self): worker = Worker() worker.configure(destination=self.image_net_home, number_of_images=5, images_per_category=10) change_spy = QSignalSpy(worker.stateChanged) worker.start_download() while not worker.complete: received = change_spy.wait(500) worker = Worker() self.assertEqual(worker.download_state, 'finished') self.assertTrue(worker.complete) worker = Worker() expected_path = os.path.abspath(self.image_net_home) state_data = json.loads(worker.state_data_json) self.assertEqual(state_data['downloadPath'], expected_path) self.assertEqual(state_data['numberOfImages'], 5) self.assertEqual(state_data['imagesPerCategory'], 10) self.assertEqual(state_data['timeLeft'], '0 seconds') self.assertEqual(state_data['imagesLoaded'], 5) self.assertEqual(state_data['failures'], 0) self.assertEqual(state_data['failedUrls'], []) self.assertEqual(state_data['progress'], 1.0)
def _wait_for_new(self, timeout, do_skip, **kwargs): """Wait for a log message which doesn't exist yet. Called via wait_for. """ __tracebackhide__ = lambda e: e.errisinstance(WaitForTimeout) message = kwargs.get('message', None) if message is not None: elided = quteutils.elide(repr(message), 50) self._log("\n----> Waiting for {} in the log".format(elided)) spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: if message is not None: self._log("----> found it") return match
def _wait_for_new(self, timeout, do_skip, **kwargs): """Wait for a log message which doesn't exist yet. Called via wait_for. """ __tracebackhide__ = lambda e: e.errisinstance(WaitForTimeout) message = kwargs.get('message', None) if message is not None: elided = quteutils.elide(repr(message), 100) self._log("\n----> Waiting for {} in the log".format(elided)) spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: # Skip if there are pending messages causing a skip self._maybe_skip() got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): msg = "Timed out after {}ms waiting for {!r}.".format( timeout, kwargs) if do_skip: pytest.skip(msg) else: raise WaitForTimeout(msg) match = self._wait_for_match(spy, kwargs) if match is not None: if message is not None: self._log("----> found it") return match raise quteutils.Unreachable
def test_normal(self, qtbot, tmpdir, ipc_server, mocker, has_cwd): ipc_server.listen() spy = QSignalSpy(ipc_server.got_args) raw_spy = QSignalSpy(ipc_server.got_raw) error_spy = QSignalSpy(ipc_server.got_invalid_data) with qtbot.waitSignal(ipc_server.got_args, raising=True, timeout=5000): with tmpdir.as_cwd(): if not has_cwd: m = mocker.patch('qutebrowser.misc.ipc.os') m.getcwd.side_effect = OSError sent = ipc.send_to_running_instance('qute-test', ['foo'], None) assert sent assert not error_spy expected_cwd = str(tmpdir) if has_cwd else '' assert len(spy) == 1 assert spy[0] == [['foo'], '', expected_cwd] assert len(raw_spy) == 1 assert len(raw_spy[0]) == 1 raw_expected = { 'args': ['foo'], 'target_arg': None, 'version': qutebrowser.__version__, 'protocol_version': ipc.PROTOCOL_VERSION } if has_cwd: raw_expected['cwd'] = str(tmpdir) parsed = json.loads(raw_spy[0][0].decode('utf-8')) assert parsed == raw_expected
def wait_for(self, timeout=None, *, override_waited_for=False, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Args: timeout: How long to wait for the message. override_waited_for: If set, gets triggered by previous messages again. Return: The matched line. """ __tracebackhide__ = True if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 if not kwargs: raise TypeError("No keyword arguments given!") for key in kwargs: assert key in self.KEYS # Search existing messages existing = self._wait_for_existing(override_waited_for, **kwargs) if existing is not None: return existing # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): raise WaitForTimeout("Timed out after {}ms waiting for " "{!r}.".format(timeout, kwargs)) for args in spy: assert len(args) == 1 line = args[0] matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches): # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line
def testStartStop(self): start_spy = QSignalSpy(self.gui.start_sgn) stop_spy = QSignalSpy(self.gui.stop_sgn) # ------------------------------------------------------------- # test when the start action button is clicked # ------------------------------------------------------------- start_action = self.gui._tool_bar.actions()[0] stop_action = self.gui._tool_bar.actions()[1] start_action.trigger() # test a ctrl widget own by the ImageToolWindow azimuthal_integ_ctrl_widget = self.gui._image_tool._azimuthal_integ_1d_view._ctrl_widget geometry_ctrl_widget = self.gui._image_tool._geometry_view._ctrl_widget pump_probe_ctrl_widget = self.gui.pump_probe_ctrl_widget histogram_ctrl_widget = self.gui.histogram_ctrl_widget source_ctrl_widget = self.gui._source_cw azimuthal_integ_ctrl_widget.updateMetaData.assert_called_once() pump_probe_ctrl_widget.updateMetaData.assert_called_once() histogram_ctrl_widget.updateMetaData.assert_called_once() source_ctrl_widget.updateMetaData.assert_called_once() self.assertEqual(1, len(start_spy)) pump_probe_ctrl_widget.onStart.assert_called_once() histogram_ctrl_widget.onStart.assert_called_once() azimuthal_integ_ctrl_widget.onStart.assert_called_once() self.assertFalse(start_action.isEnabled()) self.assertTrue(stop_action.isEnabled()) self.assertFalse(source_ctrl_widget._con_view.isEnabled()) self.assertFalse(geometry_ctrl_widget.isEnabled()) self.assertTrue(self.train_worker.running) self.assertTrue(self.pulse_worker.running) # ------------------------------------------------------------- # test when the stop action button is clicked # ------------------------------------------------------------- stop_action.trigger() pump_probe_ctrl_widget.onStop.assert_called_once() histogram_ctrl_widget.onStop.assert_called_once() azimuthal_integ_ctrl_widget.onStop.assert_called_once() self.assertEqual(1, len(stop_spy)) self.assertTrue(start_action.isEnabled()) self.assertFalse(stop_action.isEnabled()) self.assertTrue(source_ctrl_widget._con_view.isEnabled()) self.assertTrue(geometry_ctrl_widget.isEnabled()) self.assertFalse(self.train_worker.running) self.assertFalse(self.pulse_worker.running)
def wait_for(self, timeout=None, **kwargs): """Wait until a given value is found in the data. Keyword arguments to this function get interpreted as attributes of the searched data. Every given argument is treated as a pattern which the attribute has to match against. Return: The matched line. """ if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 # Search existing messages for line in self._data: matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches) and not line.waited_for: # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line # If there is none, wait for the message spy = QSignalSpy(self.new_data) elapsed_timer = QElapsedTimer() elapsed_timer.start() while True: got_signal = spy.wait(timeout) if not got_signal or elapsed_timer.hasExpired(timeout): raise WaitForTimeout("Timed out after {}ms waiting for " "{!r}.".format(timeout, kwargs)) for args in spy: assert len(args) == 1 line = args[0] matches = [] for key, expected in kwargs.items(): value = getattr(line, key) matches.append(self._match_data(value, expected)) if all(matches): # If we waited for this line, chances are we don't mean the # same thing the next time we use wait_for and it matches # this line again. line.waited_for = True return line
def test_monitor_times(self): app = QtWidgets.QApplication(sys.argv) status = DogStatus() status_spy = QSignalSpy(status.pooping.status_changed) time_spy = QSignalSpy(status.pooping.time_changed) status.start() self.assertEqual(len(time_spy), 0) status_emitted = status_spy.wait(1) self.assertTrue(status_emitted) self.assertEqual(len(time_spy), 1)
def setUp(self): self.dataNavigatorModel = DataNavigatorModel() self.dataNavigatorView = DataNavigatorView( dataModel=self.dataNavigatorModel) self.spyViewItemClicked = QSignalSpy(self.dataNavigatorView.clicked) # self.spyModelItemChanged = QSignalSpy(self.dataNavigatorModel.itemChanged[QStandardItem*]) self.spyModelDataChanged = QSignalSpy( self.dataNavigatorModel.dataChanged) self.spyModelRowsInserted = QSignalSpy( self.dataNavigatorModel.rowsInserted)
def test_case3(self): try: for i in range(9): QTest.mouseClick(gv.window.toggleButton, Qt.LeftButton) QTest.qWait(100) spy = QSignalSpy(gv.window.notify) t = spy.wait(timeout=10000) print(f"Spy signal: {t}") except Exception as e: self.fail(e)
def test_changedFontFamily(self): signalspy = QSignalSpy(self.ui.fontComboBox.currentIndexChanged) self.ui.fontComboBox.setCurrentIndex(2) # current connections for a signal self.assertEqual( self.ui.fontComboBox.receivers( self.ui.fontComboBox.currentIndexChanged), 1) self.assertEqual(len(signalspy), 1) self.assertTrue(signalspy.isValid()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.bloodTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.renalTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.liverTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.thyroidTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.electrolyteTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.lipidTextEdit.fontFamily()) self.ui.fontComboBox.setCurrentIndex(3) self.assertTrue(signalspy.isValid()) self.assertEqual(len(signalspy), 2) self.assertEqual( self.ui.fontComboBox.receivers( self.ui.fontComboBox.currentIndexChanged), 1) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.bloodTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.renalTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.liverTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.thyroidTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.electrolyteTextEdit.fontFamily()) self.assertEqual(self.ui.fontComboBox.currentText(), self.ui.lipidTextEdit.fontFamily()) for signal in signalspy: print( "That was argument's value during setCurrentIndex (for font family change) execution: ", signal[0], "\n") print("So the font family changed to ", self.ui.fontComboBox.itemText(signal[0]), "\n")
def test_wait_until_download_complete(self): worker = Worker() worker.configure(destination=self.image_net_home, number_of_images=10, images_per_category=5) change_spy = QSignalSpy(worker.stateChanged) worker.start_download() while not worker.complete: received = change_spy.wait(500) self.assertEqual(worker.download_state, 'finished') self.assertTrue(worker.complete)
def receive_message(self, sniffer): if len(sniffer.messages) > 0: return sniffer.messages.pop(0) spy = QSignalSpy(sniffer.message_sniffed) if spy.wait(self.project_manager.simulator_timeout_ms): try: return sniffer.messages.pop(0) except IndexError: self.log_message("Could not receive message") return None else: self.log_message("Receive timeout") return None
def _assert_signal_emitted(self, signal): app_state = AppState() manager = DownloadManager(app_state) conf = DownloadConfiguration(number_of_images=5, images_per_category=10, download_destination=self.image_net_home) app_state.set_configuration(conf) signal = getattr(manager, signal) spy = QSignalSpy(signal) manager.start() received = spy.wait(timeout=500) self.assertTrue(received) self.stop_the_thread(manager)
def testSetRowName1(self): self.model.initializeDataRows(COUNTER_OPTS_2, COUNTER_NAMES_2) spy = QSignalSpy(self.model.dataChanged) ROW_NAME_1 = "ISetThis" ROW_NAME_2 = "ThisToo" ROW_NAME_3 = "CantDoThis" self.model.setRowName(0, ROW_NAME_1) dataChangedData = spy[0][0] with self.assertRaises(IndexError): spy[1] self.assertEqual(dataChangedData.row(), 0) self.assertEqual(dataChangedData.column(), 0) self.assertEqual(dataChangedData.data(), ROW_NAME_1) logger.debug("Contents of QSignalSpy %s %s %s" % (spy[0][0].row(), spy[0][0].column(), spy[0][0].data())) self.model.setRowName(1, ROW_NAME_2) dataChangedData = spy[1][0] with self.assertRaises(IndexError): spy[2] self.assertEqual(dataChangedData.row(), 1) self.assertEqual(dataChangedData.column(), 0) self.assertEqual(dataChangedData.data(), ROW_NAME_2) self.model.setRowName(2, ROW_NAME_2) with self.assertRaises(IndexError): self.model.setRowName(3, ROW_NAME_2) with self.assertRaises(IndexError): self.model.setRowName(4, ROW_NAME_2) self.assertEqual(len(spy), 3)
def testImageCtrlWidget(self): widget = self.image_tool._image_ctrl_widget proc = self.pulse_worker._image_proc assembler = self.pulse_worker._assembler spy = QSignalSpy(self.image_tool._mediator.reset_image_level_sgn) widget.auto_level_btn.clicked.emit() self.assertEqual(1, len(spy)) # test default proc.update() self.assertEqual((-1e5, 1e5), proc._threshold_mask) assembler.update() self.assertEqual(False, assembler._mask_tile) # test set new value widget.threshold_mask_le.setText("1, 10") proc.update() self.assertEqual((1, 10), proc._threshold_mask) widget.mask_tile_cb.setChecked(True) assembler.update() self.assertEqual(True, assembler._mask_tile) # test loading meta data mediator = widget._mediator mediator.onImageThresholdMaskChange((-100, 10000)) mediator.onImageMaskTileEdgeChange(False) widget.loadMetaData() self.assertEqual("-100, 10000", widget.threshold_mask_le.text()) self.assertEqual(False, widget.mask_tile_cb.isChecked())
def testScanSelected(self): selectedScan = 5 specFile = os.path.join(self.dataPath, FLUORESCENCE_FILE) spyLoaded = QSignalSpy(self.scanBrowser.scanLoaded) specData = SpecDataFile(specFile) self.scanBrowser.loadScans(specData.scans) self.assertEqual(len(spyLoaded), 1) self.assertEqual(len(self.spySelected), 0) self.scanBrowser.setCurrentScan(selectedScan) self.assertEqual(len(spyLoaded), 1) self.assertEqual(len(self.spySelected), 1) self.assertEqual(self.scanBrowser.getCurrentScan(), '6') self.scanBrowser.filterByScanTypes(specData.scans, SCAN_TYPES[2]) self.assertEqual(len(spyLoaded), 2) self.assertEqual(len(self.spySelected), 1) # Doesn't register a selection change since row has not changed self.scanBrowser.setCurrentScan(selectedScan) self.assertEqual(len(spyLoaded), 2) self.assertEqual(len(self.spySelected), 1) self.assertEqual(self.scanBrowser.getCurrentScan(), '12') # Register a selection change since row changed self.scanBrowser.setCurrentScan(selectedScan + 1) self.assertEqual(len(spyLoaded), 2) self.assertEqual(len(self.spySelected), 2) self.assertEqual(self.scanBrowser.getCurrentScan(), '13')
def testPlayAllowedCard(self): spy = QSignalSpy(self._hand_panel.cardPlayed) self._hand_panel.setCards(self._cards) card = random.choice(self._cards) self._hand_panel.setAllowedCards((card, )) self._click_card_helper(card) self.assertEqual(spy[0][0], card)
def testSmartStringLineEdit(self): widget = SmartStringLineEdit("abc") spy = QSignalSpy(widget.value_changed_sgn) # set an empty string widget.clear() QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual(0, len(spy)) # set a space widget.clear() QTest.keyClicks(widget, ' ') QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual(0, len(spy)) # a string started with a space is allowed widget.clear() QTest.keyClicks(widget, ' Any') QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual(1, len(spy)) # a Karabo device ID widget.clear() QTest.keyClicks(widget, 'SA3_XTD10_MONO/MDL/PHOTON_ENERGY') QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual(2, len(spy)) # a string started with number and contains special characters and white spaces widget.clear() QTest.keyClicks(widget, '123 *$ Any') QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual(3, len(spy))
def testSmartSliceLineEdit(self): # test initialization with invalid content with self.assertRaises(ValueError): SmartSliceLineEdit("") # test initialization widget = SmartIdLineEdit("0:10:1") self.assertEqual("0:10:1", widget._cached) spy = QSignalSpy(widget.value_changed_sgn) self.assertEqual(0, len(spy)) # set an invalid value widget.clear() QTest.keyClicks(widget, "0:10:2:2") QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual("0:10:2:2", widget.text()) self.assertEqual("0:10:1", widget._cached) self.assertEqual(0, len(spy)) # set a valid value again widget.clear() QTest.keyClicks(widget, "0:10") QTest.keyPress(widget, Qt.Key_Enter) self.assertEqual("0:10", widget.text()) self.assertEqual("0:10", widget._cached) self.assertEqual(1, len(spy))
def testPlayNullCard(self): spy = QSignalSpy(self._hand_panel.cardPlayed) self._hand_panel.setCards([None, None, None]) card, rect = random.choice(self._hand_panel.cards()) self.assertIsNone(card) point = (rect.topLeft() + QPointF(1, 1)).toPoint() QTest.mouseClick(self._hand_panel, Qt.LeftButton, Qt.NoModifier, point) self.assertFalse(spy, card)
def test_cookies_changed_not_emitted(config_stub, fake_save_manager, monkeypatch, qapp): """Test that changed is not emitted when nothing changes.""" config_stub.data = CONFIG_COOKIES_ENABLED monkeypatch.setattr(lineparser, 'LineParser', LineparserSaveStub) jar = cookies.CookieJar() changed_spy = QSignalSpy(jar.changed) assert not changed_spy
def test_start_pause_and_resume(self): app_state = AppState() manager = DownloadManager(app_state) conf = DownloadConfiguration(number_of_images=5, images_per_category=1, download_destination=self.image_net_home) app_state.set_configuration(conf) paused_spy = QSignalSpy(manager.downloadPaused) resumed_spy = QSignalSpy(manager.downloadResumed) finished_spy = QSignalSpy(manager.allDownloaded) manager.start() manager.pause_download() received = paused_spy.wait(timeout=500) self.assertTrue(received) time.sleep(0.5) manager.resume_download() received = finished_spy.wait(timeout=500) self.assertTrue(received) self._assert_expected_directories_exist() self._assert_files_are_correct() self.stop_the_thread(manager)
def testCommonStartStopReset(self): win = self._win com_ctrl_widget = win._com_ctrl ctrl_widget = win._ctrl_widget client = win._client self.assertFalse(com_ctrl_widget.stop_btn.isEnabled()) self.assertIsNone(client._endpoint) with patch.object(win._client, "start") as client_start: with patch.object(win._plot_timer, "start") as timer_start: spy = QSignalSpy(win.started_sgn) QTest.mouseClick(com_ctrl_widget.start_btn, Qt.LeftButton) self.assertEqual( f"tcp://{com_ctrl_widget._hostname_le.text()}:" f"{com_ctrl_widget._port_le.text()}", client._endpoint) self.assertEqual(1, len(spy)) self.assertTrue(com_ctrl_widget.stop_btn.isEnabled()) self.assertFalse(com_ctrl_widget.start_btn.isEnabled()) self.assertFalse(com_ctrl_widget.load_dark_run_btn.isEnabled()) self.assertFalse(ctrl_widget.dummy_widget.isEnabled()) client_start.assert_called_once() timer_start.assert_called_once() with patch.object(win._client, "stop") as client_stop: with patch.object(win._plot_timer, "stop") as timer_stop: spy = QSignalSpy(win.stopped_sgn) QTest.mouseClick(com_ctrl_widget.stop_btn, Qt.LeftButton) self.assertEqual(1, len(spy)) self.assertFalse(com_ctrl_widget.stop_btn.isEnabled()) self.assertTrue(com_ctrl_widget.start_btn.isEnabled()) self.assertTrue(com_ctrl_widget.load_dark_run_btn.isEnabled()) self.assertTrue(ctrl_widget.dummy_widget.isEnabled()) client_stop.assert_called_once() timer_stop.assert_called_once() spy = QSignalSpy(win.reset_sgn) QTest.mouseClick(com_ctrl_widget.reset_btn, Qt.LeftButton) self.assertEqual(1, len(spy))
def test_multiline(qtbot, ipc_server, connected_socket): spy = QSignalSpy(ipc_server.got_args) error_spy = QSignalSpy(ipc_server.got_invalid_data) data = ('{{"args": ["one"], "target_arg": "tab",' ' "protocol_version": {version}}}\n' '{{"args": ["two"], "target_arg": null,' ' "protocol_version": {version}}}\n'.format( version=ipc.PROTOCOL_VERSION)) with qtbot.waitSignals([ipc_server.got_args, ipc_server.got_args], raising=True): connected_socket.write(data.encode('utf-8')) assert not error_spy assert len(spy) == 2 assert spy[0] == [['one'], 'tab', ''] assert spy[1] == [['two'], '', '']
def test_set_cookies_never_accept(config_stub): """Test setCookiesFromUrl when cookies are not accepted.""" config_stub.data = CONFIG_NEVER_COOKIES ram_jar = cookies.RAMCookieJar() changed_signal_spy = QSignalSpy(ram_jar.changed) url = QUrl('http://example.com/') assert not ram_jar.setCookiesFromUrl(url, 'test') assert not changed_signal_spy assert not ram_jar.cookiesForUrl(url)
def test_item_updated_triggers_data_changed(simple_app_image): model = AppImageTreeModel() interface = create_interface(simple_app_image) model.appInterface = interface spy = QSignalSpy(model.dataChanged) index = model.index(0, 0, model.index(0, 0)) interface.itemUpdated.emit('devices/jealous') assert len(spy) == 1 assert spy[0] == [index, index, []]
def test_item_updated_triggers_data_changed(simple_data): model = WatchlistModel() interface = create_interface(simple_data) model.appInterface = interface spy = QSignalSpy(model.dataChanged) index = model.index(2, 0, QModelIndex()) interface.itemUpdated.emit('garage') assert len(spy) == 1 assert spy[0] == [index, index, []]