def test_run(self): dm = DockerTaskThread.docker_manager = DockerManager.install() dm.update_config(status_callback=mock.Mock(), done_callback=mock.Mock(), work_dir=self.new_path, in_background=True) benchmark = BlenderBenchmark() task_definition = benchmark.task_definition task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = task_definition dir_manager = DirManager(self.path) task = blenderrendertask.BlenderRenderTaskBuilder( Node(), task_definition, dir_manager).build() success = mock.MagicMock() error = mock.MagicMock() self.br = BenchmarkRunner(task, self.path, success, error, benchmark) self.br.run() if self.br.tt: self.br.tt.join() self.assertEqual(success.call_count, 1)
def run_benchmark(self, benchmark, task_builder, env_id, success=None, error=None): logger.info('Running benchmark for %s', env_id) from golem.network.p2p.node import Node def success_callback(performance): logger.info('%s performance is %.2f', env_id, performance) Performance.update_or_create(env_id, performance) if success: success(performance) def error_callback(err: Union[str, Exception]): logger.error("Unable to run %s benchmark: %s", env_id, str(err)) if error: if isinstance(err, str): err = Exception(err) error(err) task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = benchmark.task_definition self._validate_task_state(task_state) builder = task_builder(Node(), task_state.definition, self.dir_manager) task = builder.build() br = BenchmarkRunner(task=task, root_path=self.dir_manager.root_path, success_callback=success_callback, error_callback=error_callback, benchmark=benchmark) br.run()
def run_benchmark(self, benchmark, label, cfg_param_name): task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = benchmark.task_definition self._validate_task_state(task_state) tb = self.get_builder(task_state) t = Task.build_task(tb) reactor = self.__get_reactor() self.br = BenchmarkRunner( t, self.datadir, lambda p: reactor.callFromThread( self._benchmark_computation_success, performance=p, label=label, cfg_param=cfg_param_name), self._benchmark_computation_error, benchmark) self.progress_dialog = TestingTaskProgressDialog( self.customizer.gui.window) self.progress_dialog_customizer = TestingTaskProgressDialogCustomizer( self.progress_dialog, self) self.progress_dialog_customizer.enable_ok_button( False) # disable 'ok' button self.customizer.gui.setEnabled('recount', False) # disable all 'recount' buttons self.progress_dialog.show() self.br.run()
def test_run(self): benchmark = BlenderBenchmark() task_definition = benchmark.task_definition task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = task_definition dir_manager = DirManager(self.path) task = Task.build_task( BlenderRenderTaskBuilder("node name", task_definition, self.path, dir_manager)) result = [None] def success(*_): result[0] = True def error(*_): result[0] = False self.br = BenchmarkRunner(task, self.path, success, error, benchmark) self.br.run() if self.br.tt: self.br.tt.join() assert result[0]
def add_task_from_definition(self, definition): task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = definition self.add_tasks([task_state])
def _get_task_state(task_id="xyz", full_task_timeout=100, subtask_timeout=50): task_state = TaskDesc() td = TestGuiApplicationLogicWithClient._get_task_definition( task_id=task_id, full_task_timeout=full_task_timeout, subtask_timeout=subtask_timeout) task_state.status = TaskStatus.notStarted task_state.definition = td return task_state
def load(self, file_name, skip_test): try: definition = self.__read_from_file(file_name) except Exception as exc: return CommandResult( error="Error reading task from file '{}': {}".format( file_name, exc)) if hasattr(definition, 'resources'): definition.resources = { os.path.normpath(res) for res in definition.resources } datadir = sync_wait(Tasks.client.get_datadir()) # TODO: unify GUI and CLI logic rendering_task_state = TaskDesc() rendering_task_state.definition = definition rendering_task_state.task_state.status = TaskStatus.starting if not Tasks.application_logic: Tasks.application_logic = CommandAppLogic.instantiate( Tasks.client, datadir) task_builder = Tasks.application_logic.get_builder( rendering_task_state) task = Task.build_task(task_builder) rendering_task_state.task_state.outputs = task.get_output_names() rendering_task_state.task_state.total_subtasks = task.get_total_tasks() task.header.task_id = str(uuid.uuid4()) if not skip_test: test_task = Task.build_task(task_builder) test_task.header.task_id = str(uuid.uuid4()) queue = Queue() TaskTester(test_task, datadir, success_callback=lambda *a, **kw: queue.put(True), error_callback=lambda *a, **kw: queue.put(a)).run() test_result = queue.get() if test_result is not True: return CommandResult( error="Test failed: {}".format(test_result)) task_dict = DictSerializer.dump(task) task_def = task_dict['task_definition'] task_def['resources'] = list(task_def.get('task_definition', [])) deferred = Tasks.client.create_task(task_dict) return sync_wait(deferred, timeout=1800)
def run_benchmark(self, benchmark, task_builder, datadir, node_name, success_callback, error_callback): task_state = TaskDesc() task_state.status = TaskStatus.notStarted task_state.definition = benchmark.task_definition self._validate_task_state(task_state) builder = task_builder(node_name, task_state.definition, datadir, self.dir_manager) t = Task.build_task(builder) br = BenchmarkRunner(t, datadir, success_callback, error_callback, benchmark) br.run()
def __test_task_button_clicked(self): self.task_state = TaskDesc() self.task_state.status = TaskStatus.notStarted self.task_state.definition = self._query_task_definition() if not self.logic.run_test_task(self.task_state): logger.error("Task not tested properly")
def test_update_preview(self): customizer = MainWindowCustomizer(self.gui.get_main_window(), MagicMock()) rts = TaskDesc(definition_class=RenderingTaskDefinition) rts.definition.output_file = "bla" customizer.update_task_additional_info(rts) assert customizer.gui.ui.outputFile.text() == "bla" assert not customizer.gui.ui.previewsSlider.isVisible() assert customizer.preview_controller.last_preview_path == customizer.preview_controller.preview_path assert customizer.gui.ui.previewLabel.pixmap().width() == 298 assert customizer.gui.ui.previewLabel.pixmap().height() == 200 img = Image.new("RGB", (250, 123), "white") img_path = os.path.join(self.path, "image1.png") img.save(img_path) rts.task_state.extra_data = {"result_preview": img_path} customizer.update_task_additional_info(rts) assert customizer.gui.ui.previewLabel.pixmap().width() == 250 assert customizer.gui.ui.previewLabel.pixmap().height() == 123 img = Image.new("RGB", (301, 206), "white") img.save(img_path) customizer.update_task_additional_info(rts) assert customizer.gui.ui.previewLabel.pixmap().width() == 301 assert customizer.gui.ui.previewLabel.pixmap().height() == 206 rts.definition.task_type = u"Blender" rts.definition.options = MagicMock() rts.definition.options.use_frames = True rts.definition.options.frames = range(10) rts.task_state.outputs = ["result"] * 10 rts.task_state.extra_data = {"result_preview": [img_path]} customizer.update_task_additional_info(rts)
def test_show_task_result(self, mock_messagebox): customizer = MainWindowCustomizer(self.gui.get_main_window(), MagicMock()) td = TaskDesc() td.definition.task_type = "Blender" td.definition.options.use_frames = True td.definition.output_file = os.path.join(self.path, "output.png") td.task_state.outputs = [ os.path.join(self.path, u"output0011.png"), os.path.join(self.path, u"output0014.png"), os.path.join(self.path, u"output0017.png") ] td.definition.options.frames = [11, 14, 17] customizer.logic.get_task.return_value = td customizer.current_task_highlighted = td customizer.gui.ui.previewsSlider.setRange(1, 3) mock_messagebox.Critical = "CRITICAL" customizer.show_task_result("abc") expected_file = td.task_state.outputs[0] mock_messagebox.assert_called_with(mock_messagebox.Critical, "Error", expected_file + u" is not a file", ANY, ANY) customizer.gui.ui.previewsSlider.setValue(2) customizer.show_task_result("abc") expected_file = td.task_state.outputs[1] mock_messagebox.assert_called_with(mock_messagebox.Critical, "Error", expected_file + u" is not a file", ANY, ANY) customizer.gui.ui.previewsSlider.setValue(3) customizer.show_task_result("abc") expected_file = td.task_state.outputs[2] mock_messagebox.assert_called_with(mock_messagebox.Critical, "Error", expected_file + u" is not a file", ANY, ANY)
def __init_basic_customizer(self): task_dialog = TaskDetailsDialog(self.gui.main_window.window) task_state = TaskDesc() ss1 = SubtaskState() ss1.subtask_id = "abc" ss1.computer.node_name ="ABC" ss1.computer.ip_address = "10.10.10.10" ss1.computer.performance = "1000" ss1.subtask_definition = "DEF 1" ss1.subtask_status = SubtaskStatus.downloading ss2 = SubtaskState() ss2.subtask_id = "def" ss2.computer.node_name = "DEF" ss2.computer.ip_address = "10.10.10.20" ss2.computer.performance = "2000" ss2.subtask_definition = "DEF 2" ss2.subtask_status = SubtaskStatus.starting ss3 = SubtaskState() ss3.subtask_id = "xyz" ss3.computer.node_name = "XYZ" ss3.computer.ip_address = "10.10.10.30" ss3.computer.performance = "3000" ss3.subtask_definition = "DEF 3" ss3.subtask_status = SubtaskStatus.finished task_state.task_state.subtask_states["abc"] = ss1 task_state.task_state.subtask_states["def"] = ss2 task_state.task_state.subtask_states["xyz"] = ss3 task_state.task_state.progress = 0.33 task_state.task_state.remaining_time = 34 task_state.task_state.elapsed_time = 12 customizer = TaskDetailsDialogCustomizer(task_dialog, self.logic, task_state) return customizer
def test_table(self): customizer = MainWindowCustomizer(self.gui.get_main_window(), MagicMock()) task1 = TaskDesc() task1.definition.task_id = "TASK ID 1" task1.status = "Finished" task1.definition.task_name = "TASK NAME 1" customizer.logic.get_task.return_value = task1 customizer.add_task(task1) assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Id).text() == "TASK ID 1" assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Name).text() == "TASK NAME 1" assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Status).text() == "Finished" assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Cost).text() == "0.000000" assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Time).text() == "00:00:00" task2 = TaskDesc() task2.definition.task_id = "TASK ID 2" task2.status = "Waiting" task2.definition.task_name = "TASK NAME 2" customizer.logic.get_task.return_value = task2 customizer.add_task(task2) assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Id).text() == "TASK ID 2" assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Name).text() == "TASK NAME 2" assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Status).text() == "Waiting" assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Cost).text() == "0.000000" assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Time).text() == "00:00:00" customizer.update_time() assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Time).text() == "00:00:00" time_ = customizer.gui.ui.taskTableWidget.item(1, ItemMap.Time).text() assert time_ != "00:00:00" task1.task_state.status = "Computing" task2.task_state.progress = 0.3 task2.task_state.status = "Paused" task2.task_state.progress = 1.0 customizer.logic.get_cost_for_task_id.return_value = 2.342 * denoms.ether tasks = {'TASK ID 1': task1, 'TASK ID 2': task2} customizer.update_tasks(tasks) customizer.update_time() assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Cost).text() == "2.342000" assert customizer.gui.ui.taskTableWidget.item( 0, ItemMap.Time).text() != "00:00:00" assert customizer.gui.ui.taskTableWidget.item( 1, ItemMap.Time).text() == time_ customizer.remove_task("TASK ID 2") customizer.logic.get_task.return_value = TaskDesc() customizer.show_change_task_dialog("ABC") customizer.change_task_dialog.close()
def test_pixmap(self): maincontroller = MagicMock() pc = PreviewController(self.gui.get_main_window(), self.logic, maincontroller) td = TaskDesc() pc.set_preview(td) point_10_10 = MagicPoint(10, 10) pc._PreviewController__pixmap_clicked(point_10_10) pc.maincontroller.show_subtask_details_dialog.assert_not_called() pc.maincontroller.current_task_highlighted = td pc._PreviewController__pixmap_clicked(point_10_10) pc.maincontroller.show_subtask_details_dialog.assert_not_called() td.definition.task_type = "TASKTYPE" td.definition.task_id = "XYZ" pc.logic.get_task.return_value = td pc._PreviewController__pixmap_clicked(point_10_10) pc.maincontroller.show_subtask_details_dialog.assert_not_called() task_type_mock = MagicMock() pc.logic.get_task_type.return_value = task_type_mock task_type_mock.get_task_num_from_pixels.return_value = 1 subtask_mock = MagicMock() subtask_mock.extra_data = {'start_task': 4, 'end_task': 5} subtask_mock.subtask_status = SubtaskStatus.finished td.task_state.subtask_states["abc"] = subtask_mock pc._PreviewController__pixmap_clicked(point_10_10) pc.maincontroller.show_subtask_details_dialog.assert_not_called() point_0_0 = MagicPoint(0, 0) pc._PreviewController__pixmap_clicked(point_0_0) pc.maincontroller.show_subtask_details_dialog.assert_not_called() subtask_mock.extra_data = {'start_task': 1, 'end_task': 2} pc._PreviewController__pixmap_clicked(point_10_10) pc.maincontroller.show_subtask_details_dialog.assert_called_with(subtask_mock) td.task_state.outputs = ["output1", "output2"] pc._PreviewController__pixmap_clicked(point_10_10) assert pc.maincontroller.show_subtask_details_dialog.call_count == 2 pc._PreviewController__mouse_on_pixmap_moved(point_0_0) assert task_type_mock.get_task_border.call_count == 0 pc._PreviewController__mouse_on_pixmap_moved(point_10_10) assert task_type_mock.get_task_border.call_count == 1 td.task_state.outputs = ["output1"] pc._PreviewController__mouse_on_pixmap_moved(point_10_10) assert task_type_mock.get_task_border.call_count == 2
def test_start_task(self): logic = GuiApplicationLogic() logic.customizer = Mock() logic.client = Mock() task_desc = TaskDesc() task_desc.task_state.status = TaskStatus.notStarted task_desc.definition.task_type = "TASKTYPE1" task_type = Mock() task_type.task_builder_type.return_value = TTaskBuilder(self.path) logic.task_types["TASKTYPE1"] = task_type logic.tasks["xyz"] = task_desc logic.start_task("xyz") assert task_desc.task_state.status == TaskStatus.starting assert task_desc.task_state.outputs == [ "output1", "output2", "output3" ]
def test_menu(self, mock_action): td = TaskDesc() TASK_ID = "TESTTTASK" td.definition.task_id = TASK_ID status = [ TaskStatus.notStarted, TaskStatus.sending, TaskStatus.waiting, TaskStatus.starting, TaskStatus.computing, TaskStatus.finished, TaskStatus.finished, TaskStatus.aborted, TaskStatus.timeout, TaskStatus.paused ] menu = None for st in status: td.task_state.status = st menu = TaskContextMenuCustomizer(Mock(), Mock(), td) assert menu is not None menu._TaskContextMenuCustomizer__abort_task_triggered() menu.logic.abort_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__restart_task_triggered() menu.logic.restart_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__delete_task_triggered() menu.logic.delete_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__clone_task_triggered() menu.logic.clone_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__start_task_triggered() menu.logic.start_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__pause_task_triggered() menu.logic.pause_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__resume_task_triggered() menu.logic.resume_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__show_task_details_triggered() menu.logic.show_task_details.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__change_task_triggered() menu.logic.change_task.assert_called_with(TASK_ID) menu._TaskContextMenuCustomizer__show_result_triggered() menu.logic.show_task_result.assert_called_with(TASK_ID)
def test_output_file(self): maincontroller = MagicMock() pc = PreviewController(self.gui.get_main_window(), self.logic, maincontroller) td = TaskDesc() # Test output color pc.set_preview(td) assert pc.gui.ui.outputFile.styleSheet() == "color: black" files = self.additional_dir_content([3]) td.definition.output_file = files[0] pc.set_preview(td) assert pc.gui.ui.outputFile.styleSheet() == "color: blue" td.task_state.outputs = files pc.maincontroller.current_task_highlighted = td pc.set_preview(td) pc.gui.ui.previewsSlider.setValue(1) assert pc.gui.ui.outputFile.text() == files[0] pc.gui.ui.previewsSlider.setRange(1, 6) pc.gui.ui.previewsSlider.setValue(4) assert pc.gui.ui.outputFile.text() == ""
def test_sorting(self): task_dialog = TaskDetailsDialog(self.gui.main_window.window) task_state = TaskDesc() customizer = TaskDetailsDialogCustomizer(task_dialog, self.logic, task_state) self.assertEqual(customizer.sorting, -1) self.assertIsNone(customizer.sorting_order) task_state.task_state.progress = 0.33 task_state.task_state.remaining_time = 34 task_state.task_state.elapsed_time = 12 ss1 = SubtaskState() ss1.computer.node_name = "ABC" ss1.subtask_id = "def" ss1.subtask_status = SubtaskStatus.finished task_state.task_state.subtask_states['def'] = ss1 ss2 = SubtaskState() ss2.computer.node_name = "DEF" ss2.subtask_id = "abc" ss2.subtask_status = SubtaskStatus.finished task_state.task_state.subtask_states['abc'] = ss2 customizer.update_view(task_state.task_state) self.assertEqual(customizer.sorting, -1) self.assertIsNone(customizer.sorting_order) self.assertEqual(len(customizer.subtask_table_elements), 2) ids = [str(customizer.gui.ui.nodesTableWidget.item(i, 1).text()) for i in range(2)] self.assertIn('def', ids) self.assertIn('abc', ids) customizer._TaskDetailsDialogCustomizer__header_clicked(1) self.assertEqual(customizer.sorting, 1) self.assertEqual(customizer.sorting_order, SortingOrder.ascending) self.assertEqual(len(customizer.subtask_table_elements), 2) self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 0).text()), "DEF") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 0).text()), "ABC") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 1).text()), "abc") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 1).text()), "def") customizer._TaskDetailsDialogCustomizer__header_clicked(1) self.assertEqual(customizer.sorting, 1) self.assertEqual(customizer.sorting_order, SortingOrder.descending) self.assertEqual(len(customizer.subtask_table_elements), 2) self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 0).text()), "ABC") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 0).text()), "DEF") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 1).text()), "def") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 1).text()), "abc") ss3 = SubtaskState() ss3.computer.node_name = "FGH" ss3.subtask_id = "fgh" ss3.subtask_status = SubtaskStatus.finished task_state.task_state.subtask_states['fgh'] = ss3 customizer.update_view(task_state.task_state) self.assertEqual(customizer.sorting, 1) self.assertEqual(customizer.sorting_order, SortingOrder.descending) self.assertEqual(len(customizer.subtask_table_elements), 3) self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 0).text()), "FGH") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 0).text()), "ABC") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 0).text()), "DEF") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 1).text()), "fgh") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 1).text()), "def") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 1).text()), "abc") customizer._TaskDetailsDialogCustomizer__header_clicked(0) self.assertEqual(customizer.sorting, 0) self.assertEqual(customizer.sorting_order, SortingOrder.ascending) self.assertEqual(len(customizer.subtask_table_elements), 3) self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 0).text()), "ABC") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 0).text()), "DEF") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 0).text()), "FGH") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 1).text()), "def") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 1).text()), "abc") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 1).text()), "fgh") customizer._TaskDetailsDialogCustomizer__header_clicked(0) self.assertEqual(customizer.sorting, 0) self.assertEqual(customizer.sorting_order, SortingOrder.descending) self.assertEqual(len(customizer.subtask_table_elements), 3) self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 0).text()), "FGH") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 0).text()), "DEF") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 0).text()), "ABC") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(0, 1).text()), "fgh") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(1, 1).text()), "abc") self.assertEqual(str(customizer.gui.ui.nodesTableWidget.item(2, 1).text()), "def")
def test_messages(self, msg_box): msg_box.return_value = msg_box logic = self.logic self.logic.datadir = self.path logic.customizer = MainWindowCustomizer(self.app.main_window, logic) logic.customizer.show_error_window = Mock() logic.customizer.show_warning_window = Mock() logic.customizer.current_task_highlighted = Mock() logic.client = Mock() self.logic.dir_manager = DirManager(self.path) register_task_types(logic) rts = TaskDesc() self.assertIsInstance(rts, TaskDesc) f = self.additional_dir_content([3]) rts.definition.task_type = "Blender" rts.definition.output_file = f[0] rts.definition.main_program_file = f[1] rts.definition.main_scene_file = f[2] self.assertTrue(logic._validate_task_state(rts)) m = Mock() broken_benchmark = BlenderBenchmark() broken_benchmark.task_definition.main_program_file = u'Bździągwa' logic.customizer.show_error_window = Mock() logic.run_benchmark(broken_benchmark, m, m) logic.progress_dialog.close() if logic.br.tt: logic.br.tt.join() logic.customizer.show_error_window.assert_called_with( u"Main program file does not exist: Bździągwa") broken_benchmark = BlenderBenchmark() broken_benchmark.task_definition.output_file = u'/x/y/Bździągwa' logic.run_benchmark(broken_benchmark, m, m) logic.progress_dialog.close() if logic.br.tt: logic.br.tt.join() logic.customizer.show_error_window.assert_called_with( u"Cannot open output file: /x/y/Bździągwa") broken_benchmark = BlenderBenchmark() broken_benchmark.task_definition.main_scene_file = "NOT EXISTING" output_file = os.path.join(self.path, str(uuid.uuid4())) broken_benchmark.task_definition.output_file = output_file logic.run_benchmark(broken_benchmark, m, m) logic.progress_dialog.close() if logic.br.tt: logic.br.tt.join() logic.customizer.show_error_window.assert_called_with( u"Main scene file NOT EXISTING is not properly set") logic.test_task_computation_error(u"Bździągwa") text = logic.progress_dialog_customizer.gui.ui.message.text() assert text == u"Task test computation failure. Bździągwa" logic.test_task_computation_error(u"500 server error") text = logic.progress_dialog_customizer.gui.ui.message.text() assert text == u"Task test computation failure. [500 server error] " \ u"There is a chance that you RAM limit is too low. " \ u"Consider increasing max memory usage" logic.test_task_computation_error(None) text = logic.progress_dialog_customizer.gui.ui.message.text() assert text == u"Task test computation failure. " logic.test_task_computation_success([], 10000, 1021, {}) text = logic.progress_dialog_customizer.gui.ui.message.text() assert text.startswith(u"Task tested successfully") logic.test_task_computation_success([], 10000, 1021, {"warnings": "Warning message"}) text = logic.progress_dialog_customizer.gui.ui.message.text() assert text.startswith(u"Task tested successfully") logic.customizer.show_warning_window.assert_called_with( "Warning message") rts.definition = BlenderBenchmark().task_definition rts.definition.output_file = 1342 self.assertFalse(logic._validate_task_state(rts)) self.assertEqual(logic._format_stats_message(("STAT1", 2424)), u"Session: STAT1; All time: 2424") self.assertEqual(logic._format_stats_message(["STAT1"]), u"Error") self.assertEqual(logic._format_stats_message(13131), u"Error") ts = TaskDesc() ts.definition.task_type = "Blender" ts.definition.main_program_file = "nonexisting" self.assertFalse(logic._validate_task_state(ts)) logic.customizer.show_error_window.assert_called_with( u"Main program file does not exist: nonexisting") with self.assertLogs(logger, level="WARNING"): logic.set_current_task_type("unknown task") def query_task_state(*_): deferred = Deferred() deferred.callback(True) return deferred logic.client.query_task_state = query_task_state with self.assertLogs(logger, level="WARNING"): logic.task_status_changed("unknown id") task_type = Mock() task_type.name = "NAME1" logic.register_new_task_type(task_type) with self.assertLogs(int_logger, level="ERROR"): logic.register_new_task_type(task_type) logic.register_new_test_task_type(task_type) with self.assertRaises(RuntimeError): logic.register_new_test_task_type(task_type)
def test_run_test_task(self, *_): logic = self.logic gui = self.app rpc_session = MockRPCSession(self.client, CORE_METHOD_MAP) rpc_client = rpc.session.Client(rpc_session, CORE_METHOD_MAP) rpc_publisher = MockRPCPublisher() logic.root_path = self.path logic.client = rpc_client self.client.datadir = logic.root_path self.client.rpc_publisher = rpc_publisher logic.customizer = MainWindowCustomizer(gui.main_window, logic) logic.customizer.new_task_dialog_customizer = Mock() logic.customizer.show_warning_window = Mock() ts = TaskDesc() files = self.additional_dir_content([1]) ts.definition.main_program_file = files[0] ts.definition.task_type = "TESTTASK" f = self.additional_dir_content([2]) ts.definition.output_file = f[0] ts.definition.main_scene_file = f[1] # FIXME Remove me task_type = Mock() ttb = TTaskBuilder(self.path) task_type.task_builder_type.return_value = ttb logic.task_types["TESTTASK"] = task_type rpc_publisher.reset() sync_wait(logic.run_test_task(ts)) logic.progress_dialog.close() logic.test_task_started(True) self.assertTrue( logic.progress_dialog_customizer.gui.ui.abortButton.isEnabled()) time.sleep(0.5) self.assertTrue(rpc_publisher.success) ttb.src_code = "import time\ntime.sleep(0.1)\n" \ "output = {'data': n, 'result_type': 0}" rpc_publisher.reset() sync_wait(logic.run_test_task(ts)) logic.progress_dialog.close() time.sleep(0.5) self.assertTrue(rpc_publisher.success) # since PythonTestVM does not support end_comp() method, # this is only a smoke test instead of actual test ttb.src_code = "import time\ntime.sleep(0.1)\n" \ "output = {'data': n, 'result_type': 0}" rpc_publisher.reset() sync_wait(logic.run_test_task(ts)) logic.progress_dialog.close() time.sleep(0.5) logic.abort_test_task() ttb.src_code = "raise Exception('some error')" rpc_publisher.reset() sync_wait(logic.run_test_task(ts)) logic.progress_dialog.close() time.sleep(1) self.assertFalse(rpc_publisher.success) rpc_publisher.reset() sync_wait(logic.run_test_task(ts)) logic.progress_dialog.close() self.assertFalse(rpc_publisher.success) ctr = logic.customizer.new_task_dialog_customizer prev_call_count = ctr.task_settings_changed.call_count logic.task_settings_changed() self.assertGreater(ctr.task_settings_changed.call_count, prev_call_count) logic.tasks["xyz"] = ts logic.clone_task("xyz") self.assertEqual( logic.customizer.new_task_dialog_customizer.load_task_definition. call_args[0][0], ts.definition) ttb = TTaskBuilder(self.path, TTaskWithDef) logic.task_types["TESTTASK"].task_builder_type.return_value = ttb assert sync_wait(logic.run_test_task(ts)) ttb = TTaskBuilder(self.path, TTaskWithError) logic.task_types["TESTTASK"].task_builder_type.return_value = ttb assert not sync_wait(logic.run_test_task(ts))
def _finish_button_clicked(self): self.task_state = TaskDesc() self.task_state.status = TaskStatus.notStarted self.task_state.definition = self._query_task_definition() self._add_current_task() self.load_task_definition(self.task_state.definition)
def test_init(self): td = TaskDesc() self.assertIsInstance(td, TaskDesc)