def test(self): workflow = self.scheme sm = TestingSignalManager() sm.set_workflow(workflow) sm.set_workflow(workflow) sm.set_workflow(None) sm.set_workflow(workflow) sm.start() self.assertFalse(sm.has_pending()) sm.stop() sm.pause() sm.resume() n0, n1, n3 = workflow.nodes sm.send(n0, n0.description.outputs[0], 'hello', None) sm.send(n1, n1.description.outputs[0], 'hello', None) spy = QSignalSpy(sm.processingFinished[SchemeNode]) self.assertTrue(spy.wait()) self.assertSequenceEqual(list(spy), [[n3]]) self.assertEqual(n3.property("-input-left"), 'hello') self.assertEqual(n3.property("-input-right"), 'hello') self.assertFalse(sm.has_pending()) workflow.remove_link(workflow.links[0]) self.assertTrue(sm.has_pending()) spy = QSignalSpy(sm.processingFinished[SchemeNode]) self.assertTrue(spy.wait()) self.assertEqual(n3.property("-input-left"), None) self.assertEqual(n3.property("-input-right"), 'hello')
def test_size_animation(self): begin_resizing = QSignalSpy(self.graph.begin_resizing) step_resizing = QSignalSpy(self.graph.step_resizing) end_resizing = QSignalSpy(self.graph.end_resizing) self._update_sizes_for_points(5) # first end_resizing is triggered in reset, thus wait for step_resizing step_resizing.wait(200) end_resizing.wait(200) self.assertEqual(len(begin_resizing), 2) # reset and update self.assertEqual(len(step_resizing), 5) self.assertEqual(len(end_resizing), 2) # reset and update self.assertEqual(self.graph.scatterplot_item.setSize.call_count, 6) self._update_sizes_for_points(6) self.graph.scatterplot_item.setSize.assert_called_once()
def test_saved_selection(self, timeout=DEFAULT_TIMEOUT): self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.widget.graph.select_by_indices(list(range(0, len(self.data), 10))) settings = self.widget.settingsHandler.pack_data(self.widget) w = self.create_widget(self.widget.__class__, stored_settings=settings) self.send_signal(self.widget.Inputs.data, self.data, widget=w) if w.isBlocking(): spy = QSignalSpy(w.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.assertEqual(np.sum(w.graph.selection), 15) np.testing.assert_equal(self.widget.graph.selection, w.graph.selection)
def test_subset_data(self, timeout=DEFAULT_TIMEOUT): """Test widget for subset data""" self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data_subset, self.data[::10])
def test_datasets(self, timeout=DEFAULT_TIMEOUT): """Test widget for datasets with missing values and constant features""" for ds in datasets.datasets(): self.send_signal(self.widget.Inputs.data, ds) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout))
def get_output(self, output, widget=None, wait=5000): """Return the last output that has been sent from the widget. Parameters ---------- output_name : str widget : Optional[OWWidget] widget whose output is returned. If not set, self.widget is used wait : int The amount of time (in milliseconds) to wait for widget to complete. Returns ------- The last sent value of given output or None if nothing has been sent. """ if widget is None: widget = self.widget if widget.isBlocking() and wait >= 0: spy = QSignalSpy(widget.blockingStateChanged) self.assertTrue(spy.wait(wait), "Failed to get output in the specified timeout") if not isinstance(output, str): output = output.name # widget.outputs are old-style signals; if empty, use new style outputs = widget.outputs or widget.Outputs.__dict__.values() assert output in (out.name for out in outputs), \ "widget {} has no output {}".format(widget.name, output) return self.signal_manager.outputs.get((widget, output), None)
def send_signal(self, input, value, *args, widget=None, wait=-1): """ Send signal to widget by calling appropriate triggers. Parameters ---------- input_name : str value : Object id : int channel id, used for inputs with flag Multiple widget : Optional[OWWidget] widget to send signal to. If not set, self.widget is used wait : int The amount of time to wait for the widget to complete. """ if widget is None: widget = self.widget if isinstance(input, str): for input_signal in widget.get_signals("inputs"): if input_signal.name == input: input = input_signal break else: raise ValueError("'{}' is not an input name for widget {}" .format(input, type(widget).__name__)) if widget.isBlocking(): raise RuntimeError("'send_signal' called but the widget is in " "blocking state and does not accept inputs.") getattr(widget, input.handler)(value, *args) widget.handleNewSignals() if wait >= 0 and widget.isBlocking(): spy = QSignalSpy(widget.blockingStateChanged) self.assertTrue(spy.wait(timeout=wait))
def _startandwait(self, widget): spy = QSignalSpy(widget.blockingStateChanged) widget.start() assert len(spy) assert spy[-1] == [True] assert spy.wait(5000) assert spy[-1] == [False] self.assertFalse(widget.isBlocking())
def test_setup_graph(self, timeout=DEFAULT_TIMEOUT): """Plot should exist after data has been sent in order to be properly set/updated""" self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.assertIsNotNone(self.widget.graph.scatterplot_item)
def get_output(self, widget, signal_name, timeout=DEFAULT_TIMEOUT): if not isinstance(signal_name, str): signal_name = signal_name.name elapsed = QElapsedTimer() if widget.isInvalidated(): elapsed.start() spy = QSignalSpy(widget.invalidatedStateChanged) assert spy.wait(timeout) timeout = timeout - elapsed.elapsed() value = self.outputs.get((widget, signal_name)) if isinstance(value, _Invalidated) and timeout >= 0: spy = QSignalSpy(value.completed) assert spy.wait( timeout), "Failed to get output in the specified timeout" assert len(spy) == 1 value = spy[0][0] return value
def test_highlighting(self): self.send_signal(self.widget.Inputs.corpus, self.corpus) # no intersection between filter and selection self.widget.regexp_filter = "graph" self.process_events() spy = QSignalSpy(self.widget.doc_webview.loadFinished) spy.wait() html = self.widget.doc_webview.html() self.assertNotIn('<mark data-markjs="true">', html) # all documents are selected self.widget.regexp_filter = "graph" self.widget.doc_list.selectAll() spy = QSignalSpy(self.widget.doc_webview.loadFinished) spy.wait() html = self.widget.doc_webview.html() self.assertIn('<mark data-markjs="true">', html)
def test_create_on_demand(self): workflow = self.scheme nodes = workflow.nodes wm = TestingWidgetManager() wm.set_creation_policy(WidgetManager.OnDemand) spy = QSignalSpy(wm.widget_for_node_added) wm.set_workflow(workflow) self.assertEqual(len(spy), 0) self.assertFalse(spy.wait(30)) self.assertEqual(len(spy), 0) w = wm.widget_for_node(nodes[0]) self.assertEqual(list(spy), [[nodes[0], w]]) # transition to normal spy = QSignalSpy(wm.widget_for_node_added) wm.set_creation_policy(WidgetManager.Normal) self.assertTrue(spy.wait()) self.assertEqual(spy[0][0], nodes[1])
def wait_for_finished( self, widget: 'OWBaseWidget', timeout=DEFAULT_TIMEOUT) -> bool: monitor = _FinishedMonitor(widget) if monitor.is_finished(): return True else: spy = QSignalSpy(monitor.finished) return spy.wait(timeout)
def test_attr_label_metas(self, timeout=DEFAULT_TIMEOUT): """Set 'Label' from string meta attribute""" data = Table("zoo") self.send_signal(self.widget.Inputs.data, data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) simulate.combobox_activate_item(self.widget.controls.attr_label, data.domain[-1].name)
def test_start_finished(self): workflow = self.scheme sm = TestingSignalManager() sm.set_workflow(workflow) sm.start() n0, n1, n3 = workflow.nodes[:3] start_spy = QSignalSpy(sm.started) fin_spy = QSignalSpy(sm.finished) sm.send(n0, n0.output_channel("value"), 'hello') sm.send(n1, n1.output_channel("value"), 'hello') assert fin_spy.wait() self.assertEqual(len(start_spy), 1) self.assertEqual(len(fin_spy), 1) sm.send(n1, n1.output_channel("value"), 'hello') assert fin_spy.wait() self.assertEqual(len(start_spy), 2) self.assertEqual(len(fin_spy), 2)
def test_overlap(self): self.send_signal(self.signal_name, self.signal_data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(5000)) self.assertEqual(len(set(self.widget.graph.get_sizes())), 1) simulate.combobox_activate_item(self.widget.controls.attr_size, OWPlotGUI.SizeByOverlap) self.assertEqual(len(set(self.widget.graph.get_sizes())), 1)
def test_class_density(self, timeout=DEFAULT_TIMEOUT): """Check class density update""" self.send_signal(self.widget.Inputs.data, self.data) self.widget.cb_class_density.click() if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data, None) self.widget.cb_class_density.click()
def test_send_report(self, timeout=DEFAULT_TIMEOUT): """Test report """ self.send_signal(self.widget.Inputs.data, self.data) self.widget.report_button.click() if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data, None) self.widget.report_button.click()
def test_highlighting_non_latin(self): documents = [{ 'content': """царстве есть сад с молодильными яблоками""" }] metas = [ (StringVariable('content'), lambda doc: doc.get('content')), ] dataset_name = 'RussianDocument' corpus = Corpus.from_documents(documents, dataset_name, metas=metas) self.send_signal(self.widget.Inputs.corpus, corpus) self.widget.regexp_filter = "\\bсад\\b" self.process_events() self.widget.doc_webview.html() spy = QSignalSpy(self.widget.doc_webview.loadFinished) spy.wait() html = self.widget.doc_webview.html() self.assertIn('<mark data-markjs="true">', html)
def test_plot_once(self, timeout=DEFAULT_TIMEOUT): """Test if data is plotted only once but committed on every input change""" table = Table("heart_disease") self.widget.setup_plot = Mock() self.widget.commit = Mock() self.send_signal(self.widget.Inputs.data, table) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.widget.setup_plot.assert_called_once() self.widget.commit.assert_called_once() self.widget.commit.reset_mock() self.send_signal(self.widget.Inputs.data_subset, table[::10]) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.widget.setup_plot.assert_called_once() self.widget.commit.assert_called_once()
def test_qinvoke_as_decorator(self): context = QObject() @qinvoke(context=context) def f(name): context.setObjectName(name) spy = QSignalSpy(context.objectNameChanged) f("name") self.assertTrue(spy.wait(500))
def test_sparse_data(self, timeout=DEFAULT_TIMEOUT): """Test widget for sparse data""" table = Table("iris").to_sparse() self.assertTrue(sp.issparse(table.X)) self.send_signal(self.widget.Inputs.data, table) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data_subset, table[::30]) self.assertEqual(len(self.widget.subset_data), 5)
def test_attr_label_metas(self, timeout=DEFAULT_TIMEOUT): """Set 'Label' from string meta attribute""" cont = Continuize(multinomial_treatment=Continuize.AsOrdinal) data = cont(Table("zoo")) self.send_signal(self.widget.Inputs.data, data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) simulate.combobox_activate_item(self.widget.controls.attr_label, data.domain[-1].name)
def test_init(self): if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) assert spy.wait(1000) self.assertFalse(self.widget.isBlocking()) model = self.widget.view.model() self.assertEqual(model.rowCount(), 3) di = self.widget.selected_dataset() self.assertEqual((di.prefix, di.filename), ("a", "c"))
def test_invalidated_embedding(self, timeout=DEFAULT_TIMEOUT): """Check if graph has been replotted when sending same data""" self.widget.graph.update_coordinates = Mock() self.widget.graph.update_point_props = Mock() self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.widget.graph.update_coordinates.assert_called() self.widget.graph.update_point_props.assert_called() self.widget.graph.update_coordinates.reset_mock() self.widget.graph.update_point_props.reset_mock() self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.widget.graph.update_coordinates.assert_not_called() self.widget.graph.update_point_props.assert_called_once()
def test_default_attrs(self, timeout=DEFAULT_TIMEOUT): """Check default values for 'Color', 'Shape', 'Size' and 'Label'""" self.send_signal(self.widget.Inputs.data, self.data) self.assertIs(self.widget.attr_color, self.data.domain.class_var) self.assertIsNone(self.widget.attr_label) self.assertIsNone(self.widget.attr_shape) self.assertIsNone(self.widget.attr_size) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data, None) self.assertIsNone(self.widget.attr_color)
def test_hidden_effective_variables(self, timeout=DEFAULT_TIMEOUT): hidden_var1 = ContinuousVariable("c1") hidden_var1.attributes["hidden"] = True hidden_var2 = ContinuousVariable("c2") hidden_var2.attributes["hidden"] = True class_vars = [DiscreteVariable("cls", values=["a", "b"])] table = Table(Domain([hidden_var1, hidden_var2], class_vars), np.array([[0., 1.], [2., 3.]]), np.array([[0.], [1.]])) self.send_signal(self.widget.Inputs.data, table) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data, table)
def test_qinvoke(self): executor = ThreadPoolExecutor() state = [None, None] # type: List[Optional[QThread]] class StateSetter(QObject): didsetstate = Signal() def set_state(self, value: QThread) -> None: state[0] = value state[1] = QThread.currentThread() self.didsetstate.emit() def func(callback): # type: (Callable[[QThread], None]) -> None callback(QThread.currentThread()) obj = StateSetter() spy = QSignalSpy(obj.didsetstate) f = executor.submit( func, qinvoke(obj.set_state, context=obj) ) self.assertTrue(spy.wait()) self.assertIs(state[1], QThread.currentThread(), "set_state was called from the wrong thread") self.assertIsNot(state[0], QThread.currentThread(), "set_state was invoked in the main thread") # test that disconnect works 'atomically' w.r.t. event loop spy = QSignalSpy(obj.didsetstate) callback = qinvoke(obj.set_state, context=obj) f = executor.submit(func, callback) f.result() time.sleep(0.01) # wait for finish callback.disconnect() # type: ignore self.assertFalse(spy.wait(100), "") self.assertSequenceEqual(spy, []) executor.shutdown(wait=True)
def test_subset_data_color(self, timeout=DEFAULT_TIMEOUT): self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data_subset, self.data[:10]) subset = [brush.color().name() == "#46befa" for brush in self.widget.graph.scatterplot_item.data['brush'][:10]] other = [brush.color().name() == "#000000" for brush in self.widget.graph.scatterplot_item.data['brush'][10:]] self.assertTrue(all(subset)) self.assertTrue(all(other))
def test_sparse_data(self, timeout=DEFAULT_TIMEOUT): """Test widget for sparse data""" # scipy.sparse uses matrix; this filter can be removed when it stops warnings.filterwarnings("ignore", ".*the matrix subclass.*", PendingDeprecationWarning) table = Table("iris").to_sparse() self.assertTrue(sp.issparse(table.X)) self.send_signal(self.widget.Inputs.data, table) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data_subset, table[::30]) self.assertEqual(len(self.widget.subset_data), 5)
def test_sparse_data(self, timeout=DEFAULT_TIMEOUT): """Test widget for sparse data""" # scipy.sparse uses matrix; this filter can be removed when it stops warnings.filterwarnings( "ignore", ".*the matrix subclass.*", PendingDeprecationWarning) table = Table("iris").to_sparse() self.assertTrue(sp.issparse(table.X)) self.send_signal(self.widget.Inputs.data, table) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) self.send_signal(self.widget.Inputs.data_subset, table[::30]) self.assertEqual(len(self.widget.subset_data), 5)
def test_state_ready(self): model, widgets = create_workflow() sm = model.signal_manager widgets.w1.Outputs.out.send(42) widgets.w2.Outputs.out.send(-42) widgets.add.setReady(False) self.assertFalse(sm.is_ready(widgets.add_node)) spy = QSignalSpy(sm.processingStarted[SchemeNode]) sm.process_next() self.assertEqual(len(spy), 0) # must not have processed the node widgets.add.setReady(True) self.assertTrue(sm.is_ready(widgets.add_node)) assert spy.wait() self.assertSequenceEqual(spy, [[widgets.add_node]])
def test_copy_cut_paste(self): item = self.item cb = QApplication.clipboard() c = item.textCursor() c.select(c.Document) item.setTextCursor(c) menu = self._context_menu() ac = find_action(menu, "edit-copy") spy = QSignalSpy(cb.dataChanged) ac.trigger() self.assertTrue(len(spy) or spy.wait()) ac = find_action(menu, "edit-cut") spy = QSignalSpy(cb.dataChanged) ac.trigger() self.assertTrue(len(spy) or spy.wait()) self.assertEqual(item.toPlainText(), "") ac = find_action(menu, "edit-paste") ac.trigger() self.assertEqual(item.toPlainText(), "AAA")
def test_invalidated_embedding(self): self.widget.graph.update_coordinates = unittest.mock.Mock() self.widget.graph.update_point_props = unittest.mock.Mock() self.send_signal(self.widget.Inputs.data, self.data) self.widget.graph.update_coordinates.assert_called_once() self.widget.graph.update_point_props.assert_called_once() if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(5000)) self.widget.graph.update_coordinates.reset_mock() self.widget.graph.update_point_props.reset_mock() self.send_signal(self.widget.Inputs.data, self.data) self.widget.graph.update_coordinates.assert_not_called() self.widget.graph.update_point_props.assert_called_once()
def test_output_preprocessor(self): self.reset_tsne() self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(20000)) pp = self.get_output(self.widget.Outputs.preprocessor) self.assertIsInstance(pp, Preprocess) transformed = pp(self.data) self.assertIsInstance(transformed, Table) self.assertEqual(transformed.X.shape, (len(self.data), 2)) output = self.get_output(self.widget.Outputs.annotated_data) np.testing.assert_allclose(transformed.X, output.metas[:, :2], rtol=1, atol=1) self.assertEqual([a.name for a in transformed.domain.attributes], [m.name for m in output.domain.metas[:2]])
def test_in_out_summary(self, timeout=DEFAULT_TIMEOUT): info = self.widget.info self.assertEqual(info._StateInfo__input_summary.brief, "") self.assertEqual(info._StateInfo__output_summary.brief, "") self.send_signal(self.widget.Inputs.data, self.data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) ind = self._select_data() self.assertEqual(info._StateInfo__input_summary.brief, str(len(self.data))) self.assertEqual(info._StateInfo__output_summary.brief, str(len(ind))) self.send_signal(self.widget.Inputs.data, None) self.assertEqual(info._StateInfo__input_summary.brief, "") self.assertEqual(info._StateInfo__output_summary.brief, "")
def wait_until_stop_blocking(self, widget=None, wait=DEFAULT_TIMEOUT): """Wait until the widget stops blocking i.e. finishes computation. Parameters ---------- widget : Optional[OWBaseWidget] widget to send signal to. If not set, self.widget is used wait : int The amount of time to wait for the widget to complete. """ if widget is None: widget = self.widget if widget.isBlocking(): spy = QSignalSpy(widget.blockingStateChanged) self.assertTrue(spy.wait(timeout=wait))
def test_state_invalidated(self): model, widgets = create_workflow() sm = model.signal_manager widgets.w1.Outputs.out.send(42) widgets.w2.Outputs.out.send(-42) self.assertIn(widgets.add_node, sm.node_update_front()) widgets.w1.setInvalidated(True) self.assertTrue(sm.is_invalidated(widgets.w1_node)) self.assertSequenceEqual(sm.node_update_front(), []) widgets.w1.setInvalidated(False) self.assertFalse(sm.is_invalidated(widgets.w1_node)) self.assertIn(widgets.add_node, sm.node_update_front()) spy = QSignalSpy(sm.processingStarted[SchemeNode]) assert spy.wait() self.assertSequenceEqual(spy, [[widgets.add_node]])
def wait_until_stop_blocking(self, widget=None, wait=DEFAULT_TIMEOUT): """Wait until the widget stops blocking i.e. finishes computation. Parameters ---------- widget : Optional[OWWidget] widget to send signal to. If not set, self.widget is used wait : int The amount of time to wait for the widget to complete. """ if widget is None: widget = self.widget if widget.isBlocking(): spy = QSignalSpy(widget.blockingStateChanged) self.assertTrue(spy.wait(timeout=wait))
def test_ready_flags(self): workflow = self.scheme sm = TestingSignalManager() sm.set_workflow(workflow) sm.start() n0, n1, n3 = workflow.nodes[:3] sm.send(n0, n0.output_channel("value"), 'hello') sm.send(n1, n1.output_channel("value"), 'hello') self.assertIn(n3, sm.node_update_front()) n3.set_state_flags(SchemeNode.NotReady, True) spy = QSignalSpy(sm.processingStarted[SchemeNode]) sm.process_next() self.assertNotIn([n3], list(spy)) n3.set_state_flags(SchemeNode.NotReady, False) assert spy.wait() self.assertIn([n3], list(spy))
def send_signals(self, signals, *args, widget=None, wait=-1): """ Send signals to widget by calling appropriate triggers. After all the signals are send, widget's handleNewSignals() in invoked. Parameters ---------- signals : list of (str, Object) widget : Optional[OWWidget] widget to send signals to. If not set, self.widget is used wait : int The amount of time to wait for the widget to complete. """ if widget is None: widget = self.widget for input, value in signals: self._send_signal(widget, input, value, *args) widget.handleNewSignals() if wait >= 0 and widget.isBlocking(): spy = QSignalSpy(widget.blockingStateChanged) self.assertTrue(spy.wait(timeout=wait))
def test_outputs(self, timeout=DEFAULT_TIMEOUT): self.send_signal(self.signal_name, self.signal_data) if self.widget.isBlocking(): spy = QSignalSpy(self.widget.blockingStateChanged) self.assertTrue(spy.wait(timeout)) # check selected data output self.assertIsNone(self.get_output("Selected Data")) # check annotated data output feature_name = ANNOTATED_DATA_FEATURE_NAME annotated = self.get_output(ANNOTATED_DATA_SIGNAL_NAME) self.assertEqual(0, np.sum([i[feature_name] for i in annotated])) # select data instances selected_indices = self._select_data() # check selected data output selected = self.get_output("Selected Data") n_sel, n_attr = len(selected), len(self.data.domain.attributes) self.assertGreater(n_sel, 0) self.assertEqual(selected.domain == self.data.domain, self.same_input_output_domain) np.testing.assert_array_equal(selected.X[:, :n_attr], self.data.X[selected_indices]) self.assertEqual(selected.attributes, self.data.attributes) # check annotated data output annotated = self.get_output(ANNOTATED_DATA_SIGNAL_NAME) self.assertEqual(n_sel, np.sum([i[feature_name] for i in annotated])) self.assertEqual(annotated.attributes, self.data.attributes) # compare selected and annotated data domains self._compare_selected_annotated_domains(selected, annotated) # check output when data is removed self.send_signal(self.signal_name, None) self.assertIsNone(self.get_output("Selected Data")) self.assertIsNone(self.get_output(ANNOTATED_DATA_SIGNAL_NAME))
def test_discrete_editor_add_remove_action(self): w = DiscreteVariableEditor() v = Categorical("C", ("a", "b", "c"), (("A", "1"), ("B", "b"))) w.set_data(v) action_add = w.add_new_item action_remove = w.remove_item view = w.values_edit model, selection = view.model(), view.selectionModel() selection.clear() action_add.trigger() self.assertTrue(view.state() == view.EditingState) editor = view.focusWidget() assert isinstance(editor, QLineEdit) spy = QSignalSpy(model.dataChanged) QTest.keyClick(editor, Qt.Key_D) QTest.keyClick(editor, Qt.Key_Return) self.assertTrue(model.rowCount() == 4) # The commit to model is executed via a queued invoke self.assertTrue(bool(spy) or spy.wait()) self.assertEqual(model.index(3, 0).data(Qt.EditRole), "d") # remove it spy = QSignalSpy(model.rowsRemoved) action_remove.trigger() self.assertEqual(model.rowCount(), 3) self.assertEqual(len(spy), 1) _, first, last = spy[0] self.assertEqual((first, last), (3, 3)) # remove/drop and existing value selection.select(model.index(1, 0), QItemSelectionModel.ClearAndSelect) removespy = QSignalSpy(model.rowsRemoved) changedspy = QSignalSpy(model.dataChanged) action_remove.trigger() self.assertEqual(len(removespy), 0, "Should only mark item as removed") self.assertGreaterEqual(len(changedspy), 1, "Did not change data") w.grab()