def construct_project(datapath, temp_dir_for_excludes=None): settings = FakeSettings({"excludes": temp_dir_for_excludes}) library_manager = LibraryManager(":memory:") library_manager.create_database() project = Project(Namespace(settings), settings, library_manager) project.load_data(datapath, NullObserver()) return project
def construct_project(datapath, temp_dir_for_excludes=None): settings = FakeSettings({'excludes': temp_dir_for_excludes}) library_manager = LibraryManager(':memory:') library_manager.create_database() project = Project(Namespace(settings), settings, library_manager) project.load_data(datapath, NullObserver()) return project
def construct_project(datapath, temp_dir_for_excludes=None): # print("DEBUG: construct_project with argpath: %s\n" % datapath) settings = FakeSettings({'excludes': temp_dir_for_excludes}) #print("DEBUG: construct_project FakeSettings: %s\n" % list(settings.iteritems())) library_manager = LibraryManager(':memory:') library_manager.create_database() project = Project(Namespace(settings), settings, library_manager) # print("DEBUG: construct_project Project: %s\n" % project.display_name) project.load_data(datapath) #, NullObserver()) # DEBUG # print("DEBUG: Path arg is: %s\n" % datapath) return project
class ProjectTest(unittest.TestCase): def setUp(self): self._library_manager = _library_manager() self.ctrl = Project(Namespace(FakeSettings()), FakeSettings(), self._library_manager) self.load_observer = MessageRecordingLoadObserver() self.suite_listener = PublisherListener(RideOpenSuite) self.resource_listener = PublisherListener(RideOpenResource) def tearDown(self): self.suite_listener.unsubscribe() self.resource_listener.unsubscribe() self.ctrl.close() self._library_manager.stop() def test_loading_suite_at_startup(self): self._load(MINIMAL_SUITE_PATH) assert_true(self.ctrl._controller is not None) self._test_listeners([MINIMAL_SUITE_PATH], []) def _test_listeners(self, suite_paths, resource_paths): self.assertEqual(self._get_paths(self.suite_listener.data), suite_paths) self.assertEqual(self._get_paths(self.resource_listener.data), resource_paths) def _get_paths(self, data): return [item.path for item in data] def test_loading_resource_at_startup(self): self._load(RESOURCE_PATH) assert_true(self.ctrl.resources != []) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS) def test_loading_invalid_data_at_startup(self): msg = "Given file 'invalid' is not a valid Robot Framework test case or resource file." self.ctrl.load_data('invalid', self.load_observer) assert_true(self.load_observer.finished) assert_equal(self.load_observer.message, msg) self._test_listeners([], []) def _load(self, path): self.ctrl.load_data(path, self.load_observer) assert_true(self.load_observer.notified) assert_true(self.load_observer.finished) def test_loading_datafile(self): data = self.ctrl.load_datafile(MINIMAL_SUITE_PATH, self.load_observer) assert_true(self.load_observer.finished) assert_true(data is not None) self._test_listeners([MINIMAL_SUITE_PATH], []) def test_reloading(self): self.ctrl.new_file_project(MINIMAL_SUITE_PATH) files1 = self.ctrl.datafiles self.ctrl.new_file_project(MINIMAL_SUITE_PATH) files2 = self.ctrl.datafiles assert_true(files1 != files2) def test_loading_resource_file(self): resource = self.ctrl.load_resource(RESOURCE_PATH, self.load_observer) assert_true(self.load_observer.finished) assert_true(resource is not None) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS) def test_loading_invalid_datafile(self): self.ctrl.load_datafile('invalid', self.load_observer) assert_equal(self.load_observer.message, "Invalid data file 'invalid'.") self._test_listeners([], []) def test_loading_invalid_resource(self): assert_is_none(self.ctrl.load_resource('invalid', self.load_observer)) assert_equal(self.load_observer.message, "Invalid resource file 'invalid'.") self._test_listeners([], []) def test_dirtyness(self): self.ctrl.load_data(COMPLEX_SUITE_PATH, MessageRecordingLoadObserver()) assert_true(not self.ctrl.is_dirty()) self.ctrl.data.create_test('newnessness') assert_true(self.ctrl.is_dirty()) def test_load_dirty_controllers(self): self.ctrl.load_data(SUITEPATH, MessageRecordingLoadObserver()) assert_equal(len(self.ctrl._get_all_dirty_controllers()), 0) tcf = self._find_suite_by_type(self.ctrl.data.children, TestCaseFileController) tcf.create_test('newnessness') assert_equal(len(self.ctrl._get_all_dirty_controllers()), 1) self.ctrl.data.mark_dirty() assert_equal(len(self.ctrl._get_all_dirty_controllers()), 2) sub_dir = self._find_suite_by_type(self.ctrl.data.children, TestDataDirectoryController) sub_dir_tcf = self._find_suite_by_type(sub_dir.children, TestCaseFileController) sub_dir_tcf.create_test('newnessness') assert_equal(len(self.ctrl._get_all_dirty_controllers()), 3) def _find_suite_by_type(self, suites, type): for child in suites: if isinstance(child, type): return child return None def test_creating_new_resource(self): controller = self.ctrl.new_resource('somepath') assert_equal(controller.name, 'Somepath') def test_resource_with_same_path_is_not_added_twice(self): self.ctrl.new_resource('somepath') self.ctrl.new_resource('somepath') assert_equal(len(self.ctrl.resources), 1) def test_load_data_with_external_resources_all_externals_are_used(self): are_used = [] def handle(message): are_used.append(message.datafile.is_used()) self.resource_listener.outer_listener = handle self._load(EXTERNAL_RES_UNSORTED_PATH) assert_true(self.ctrl.resources != []) res_path = os.path.join( os.path.split(EXTERNAL_RES_UNSORTED_PATH)[0], 'external_resources') abc_path = os.path.join(res_path, 'subdirectory2', 'subsubdirectory', 'Abc.txt') bar_path = os.path.join(res_path, 'subdirectory2', 'bar.txt') foo_path = os.path.join(res_path, 'subdirectory', 'Foo.txt') hello_path = os.path.join(res_path, 'subdirectory2', 'subsubdirectory', 'hello.txt') resource_path = os.path.join(res_path, 'subdirectory2', 'Resource.txt') self.assertEqual(are_used, [True for _ in range(5)]) self._test_listeners( [EXTERNAL_RES_UNSORTED_PATH], [abc_path, bar_path, foo_path, hello_path, resource_path]) def test_sort_external_resources(self): self.ctrl.load_data(EXTERNAL_RES_UNSORTED_PATH, MessageRecordingLoadObserver()) assert_equal([res.name for res in self.ctrl.external_resources], ["Abc", "Bar", "Foo", "Hello", "Resource"]) def test_datafiles_property_with_resource_file_only(self): resource = self.ctrl.load_resource(RESOURCE_PATH, self.load_observer) assert_equal(self.ctrl.datafiles[0], resource) def test_get_all_keywords_with_resource_file_only(self): project = datafilereader.construct_project(RESOURCE_PATH) all_kws = project.get_all_keywords() project.close() res_kws = [kw for kw in all_kws if kw.name == 'Resource UK'] assert_equal(len(res_kws), 1) def test_resource_import_modified(self): self.ctrl.resource_import_modified(RELATIVE_PATH_TO_RESOURCE_FILE, DATAPATH) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS)
class ProjectTest(unittest.TestCase): def setUp(self): self._library_manager = _library_manager() self.ctrl = Project(Namespace(FakeSettings()), FakeSettings(), self._library_manager) self.load_observer = MessageRecordingLoadObserver() self.suite_listener = PublisherListener(RideOpenSuite) self.resource_listener = PublisherListener(RideOpenResource) def tearDown(self): self.suite_listener.unsubscribe() self.resource_listener.unsubscribe() self.ctrl.close() self._library_manager.stop() def test_loading_suite_at_startup(self): self._load(MINIMAL_SUITE_PATH) assert_true(self.ctrl._controller is not None) self._test_listeners([MINIMAL_SUITE_PATH], []) def _test_listeners(self, suite_paths, resource_paths): self.assertEqual(self._get_paths(self.suite_listener.data), suite_paths) self.assertEqual(self._get_paths(self.resource_listener.data), resource_paths) def _get_paths(self, data): return [item.path for item in data] def test_loading_resource_at_startup(self): self._load(RESOURCE_PATH) assert_true(self.ctrl.resources != []) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS) def test_loading_invalid_data_at_startup(self): msg = "Given file 'invalid' is not a valid Robot Framework test case or resource file." self.ctrl.load_data('invalid', self.load_observer) assert_true(self.load_observer.finished) assert_equals(self.load_observer.message, msg) self._test_listeners([], []) def _load(self, path): self.ctrl.load_data(path, self.load_observer) assert_true(self.load_observer.notified) assert_true(self.load_observer.finished) def test_loading_datafile(self): data = self.ctrl.load_datafile(MINIMAL_SUITE_PATH, self.load_observer) assert_true(self.load_observer.finished) assert_true(data is not None) self._test_listeners([MINIMAL_SUITE_PATH], []) def test_reloading(self): self.ctrl.new_file_project(MINIMAL_SUITE_PATH) files1 = self.ctrl.datafiles self.ctrl.new_file_project(MINIMAL_SUITE_PATH) files2 = self.ctrl.datafiles assert_true(files1 != files2) def test_loading_resource_file(self): resource = self.ctrl.load_resource(RESOURCE_PATH, self.load_observer) assert_true(self.load_observer.finished) assert_true(resource is not None) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS) def test_loading_invalid_datafile(self): self.ctrl.load_datafile('invalid', self.load_observer) assert_equals(self.load_observer.message, "Invalid data file 'invalid'.") self._test_listeners([], []) def test_loading_invalid_resource(self): assert_none(self.ctrl.load_resource('invalid', self.load_observer)) assert_equals(self.load_observer.message, "Invalid resource file 'invalid'.") self._test_listeners([], []) def test_dirtyness(self): self.ctrl.load_data(COMPLEX_SUITE_PATH, MessageRecordingLoadObserver()) assert_true(not self.ctrl.is_dirty()) self.ctrl.data.create_test('newnessness') assert_true(self.ctrl.is_dirty()) def test_load_dirty_controllers(self): self.ctrl.load_data(SUITEPATH, MessageRecordingLoadObserver()) assert_equals(len(self.ctrl._get_all_dirty_controllers()), 0) tcf = self._find_suite_by_type(self.ctrl.data.children, TestCaseFileController) tcf.create_test('newnessness') assert_equals(len(self.ctrl._get_all_dirty_controllers()), 1) self.ctrl.data.mark_dirty() assert_equals(len(self.ctrl._get_all_dirty_controllers()), 2) sub_dir = self._find_suite_by_type(self.ctrl.data.children, TestDataDirectoryController) sub_dir_tcf = self._find_suite_by_type(sub_dir.children, TestCaseFileController) sub_dir_tcf.create_test('newnessness') assert_equals(len(self.ctrl._get_all_dirty_controllers()), 3) def _find_suite_by_type(self, suites, type): for child in suites: if isinstance(child, type): return child return None def test_creating_new_resource(self): controller = self.ctrl.new_resource('somepath') assert_equals(controller.name, 'Somepath') def test_resource_with_same_path_is_not_added_twice(self): self.ctrl.new_resource('somepath') self.ctrl.new_resource('somepath') assert_equals(len(self.ctrl.resources), 1) def test_load_data_with_external_resources_all_externals_are_used(self): are_used = [] def handle(message): are_used.append(message.datafile.is_used()) self.resource_listener.outer_listener = handle self._load(EXTERNAL_RES_UNSORTED_PATH) assert_true(self.ctrl.resources != []) res_path = os.path.join(os.path.split(EXTERNAL_RES_UNSORTED_PATH)[0], 'external_resources') abc_path = os.path.join(res_path, 'subdirectory2', 'subsubdirectory', 'Abc.txt') bar_path = os.path.join(res_path, 'subdirectory2', 'bar.txt') foo_path = os.path.join(res_path, 'subdirectory', 'Foo.txt') hello_path = os.path.join(res_path, 'subdirectory2', 'subsubdirectory', 'hello.txt') resource_path = os.path.join(res_path, 'subdirectory2', 'Resource.txt') self.assertEqual(are_used, [True for _ in range(5)]) self._test_listeners([EXTERNAL_RES_UNSORTED_PATH], [abc_path, bar_path, foo_path, hello_path, resource_path]) def test_sort_external_resources(self): self.ctrl.load_data(EXTERNAL_RES_UNSORTED_PATH, MessageRecordingLoadObserver()) assert_equals([res.name for res in self.ctrl.external_resources], ["Abc", "Bar", "Foo", "Hello", "Resource"]) def test_datafiles_property_with_resource_file_only(self): resource = self.ctrl.load_resource(RESOURCE_PATH, self.load_observer) assert_equals(self.ctrl.datafiles[0], resource) def test_get_all_keywords_with_resource_file_only(self): project = datafilereader.construct_project(RESOURCE_PATH) all_kws = project.get_all_keywords() project.close() res_kws = [kw for kw in all_kws if kw.name == 'Resource UK'] assert_equals(len(res_kws), 1) def test_resource_import_modified(self): self.ctrl.resource_import_modified(RELATIVE_PATH_TO_RESOURCE_FILE, DATAPATH) self._test_listeners([], ALL_RESOURCE_PATH_RELATED_RESOURCE_IMPORTS)
class RIDE(wx.App): def __init__(self, path=None, updatecheck=True): self._initial_path = path self._updatecheck = updatecheck context.APP = self wx.App.__init__(self, redirect=False) def OnInit(self): # Needed for SetToolTipString to work wx.HelpProvider_Set(wx.SimpleHelpProvider()) self.settings = RideSettings() librarydatabase.initialize_database() self.preferences = Preferences(self.settings) self.namespace = Namespace(self.settings) self._controller = Project(self.namespace, self.settings) self.frame = RideFrame(self, self._controller) self._editor_provider = EditorProvider() self._plugin_loader = PluginLoader(self, self._get_plugin_dirs(), coreplugins.get_core_plugins()) self._plugin_loader.enable_plugins() self.editor = self._get_editor() self.editor.show() self._load_data() self.frame.tree.populate(self.model) self.frame.tree.set_editor(self.editor) self._publish_system_info() if self._updatecheck: UpdateNotifierController(self.settings).notify_update_if_needed(UpdateDialog) wx.CallLater(200, ReleaseNotes(self).bring_to_front) return True def _publish_system_info(self): RideLogMessage(context.SYSTEM_INFO).publish() @property def model(self): return self._controller def _get_plugin_dirs(self): return [self.settings.get_path('plugins'), os.path.join(self.settings['install root'], 'site-plugins'), contrib.CONTRIB_PATH] def _get_editor(self): from robotide.editor import EditorPlugin for pl in self._plugin_loader.plugins: if isinstance(pl._plugin, EditorPlugin): return pl._plugin def _load_data(self): path = self._initial_path or self._get_latest_path() if path: with self.active_event_loop(): observer = LoadProgressObserver(self.frame) self._controller.load_data(path, observer) def _get_latest_path(self): recent = self._get_recentfiles_plugin() if not recent or not recent.recent_files: return None return recent.recent_files[0] def _get_recentfiles_plugin(self): from robotide.recentfiles import RecentFilesPlugin for pl in self.get_plugins(): if isinstance(pl._plugin, RecentFilesPlugin): return pl._plugin def get_plugins(self): return self._plugin_loader.plugins def register_preference_panel(self, panel_class): '''Add the given panel class to the list of known preference panels''' self.preferences.add(panel_class) def unregister_preference_panel(self, panel_class): '''Remove the given panel class from the list of known preference panels''' self.preferences.remove(panel_class) def register_editor(self, object_class, editor_class, activate): self._editor_provider.register_editor(object_class, editor_class, activate) def unregister_editor(self, object_class, editor_class): self._editor_provider.unregister_editor(object_class, editor_class) def activate_editor(self, object_class, editor_class): self._editor_provider.set_active_editor(object_class, editor_class) def get_editors(self, object_class): return self._editor_provider.get_editors(object_class) def get_editor(self, object_class): return self._editor_provider.get_editor(object_class) @contextmanager def active_event_loop(self): # With wxPython 2.9.1, ProgressBar.Pulse breaks if there's no active # event loop. # See http://code.google.com/p/robotframework-ride/issues/detail?id=798 loop = wx.EventLoop() wx.EventLoop.SetActive(loop) yield del loop
class RIDE(object): def __init__(self, random, path): print 'librarydatabase.initialize_database()' print librarydatabase.initialize_database() print 'settings = RideSettings()' print 'project = Project(Namespace(settings=settings), settings=settings)' settings = RideSettings() self._project = Project(Namespace(settings=settings), settings=settings) self._path = path self._suite = None self._test = None self._keyword = None self._random = random self._skip = False def _skip_until_notified(self): self._skip = True def _do_not_skip(self): self._skip = False def open_test_dir(self): if self._skip: return self._open(os.path.join(self._path, 'testdir')) print 'suite = project.data.children[0]' self._suite = self._project.data.children[0] print 'test = list(t for t in suite.tests)[0]' self._test = list(t for t in self._suite.tests)[0] print 'keyword = list(k for k in suite.keywords)[0]' self._keyword = list(k for k in self._suite.keywords)[0] def open_suite_file(self): if self._skip: return self._open(os.path.join(self._path, 'testdir', 'Suite.txt')) print 'suite = project.data' self._suite = self._project.data print 'test = list(t for t in suite.tests)[0]' self._test = list(t for t in self._suite.tests)[0] print 'keyword = list(k for k in suite.keywords)[0]' self._keyword = list(k for k in self._suite.keywords)[0] def _open_resource_file(self): self._open(os.path.join(self._path, 'testdir', 'resources', 'resu.txt')) self._suite = None self._test = None self._keyword = None def _open(self, path): print 'project.load_data("%s", NullObserver())' % path self._project.load_data(path, NullObserver()) def _create_suite(self): filename = os.path.join(self._path, 'path_to_foo%s.txt' % str(self._rand())) print 'suite = project.data.execute(AddSuite(NewDatafile("%s")))' % filename self._suite = self._project.data.execute(AddTestCaseFile(filename)) def create_test(self): if self._skip: self._rand() return testname = 'foobar' + str(self._rand()) print 'test = suite.execute(AddTestCase("%s"))' % testname self._test = self._suite.execute(AddTestCase(testname)) def change_test_order(self): self._change_order([t.data for t in self._suite.tests], self._suite.tests) def _change_order(self, items, controller): command = MoveUp if self._rand() > 0.5 else MoveDown r = self._rand() if self._skip: return items = list(items) if items: i = int(r * (len(items))) print '%s.execute(%s(items[%d]))' % (controller.__class__.__name__, command.__name__, i) controller.execute(command(items[i])) def _rand(self): return self._random.random() def _rand_row(self): return self._random.randint(0, 100) def _rand_col(self): return self._random.randint(0, 30) def create_keyword(self): if self._skip: self._rand() return keyword_name = 'kwFoobar' + str(self._rand()) print 'keyword = suite.execute(AddKeyword("%s"))' % keyword_name self._keyword = self._suite.execute(AddKeyword(keyword_name)) def change_keyword_order(self): pass def add_variable(self): if self._skip: self._rand() self._rand() return command = AddVariable('${var%s}' % str(self._rand()), str(self._rand()), 'comment') print 'suite.execute(%s)' % str(command) self._suite.execute(command) def change_variable_order(self): pass def write_cell_data(self): value = self._random.choice([ '# something', 'foobar', ': FOR', '${var}', 'No Operation', '\\', 'zoo%d' % self._rand(), '${%d}' % self._rand() ]) self._macro_execute( ChangeCellValue(self._rand_row(), self._rand_col(), value)) def write_for_loop(self): self._macro_execute( InsertArea((self._rand_row(), 0), [[':FOR', '${i}', 'IN', '1', '2', 'foo'], ['', 'No Operation']])) def _macro_execute(self, command): macro = self._random.choice( [c for c in [self._test, self._keyword] if c]) if not self._skip: print '%s.execute(%s)' % (self._name(macro), str(command)) macro.execute(command) def _name(self, macro): if macro == self._test: return 'test' return 'keyword' def add_row(self): self._macro_execute(AddRow(self._rand_row())) def remove_row(self): self._macro_execute(DeleteRow(self._rand_row())) def add_cell(self): self._macro_execute(InsertCell(self._rand_row(), self._rand_col())) def remove_cell(self): self._macro_execute(DeleteCell(self._rand_row(), self._rand_col())) def move_row_up(self): self._macro_execute(MoveRowsUp([self._rand_row()])) def move_row_down(self): self._macro_execute(MoveRowsDown([self._rand_row()])) def extract_keyword(self): first_row = self._rand_row() self._macro_execute( ExtractKeyword( 'foo', '', [first_row, first_row + self._random.randint(1, 10)])) def add_library_import(self): if not self._skip: print 'suite.imports.execute(AddLibrary(["OperatingSystem", "", ""], "#comment"))' self._suite.imports.execute( AddLibrary(['OperatingSystem', '', ''], '#comment')) def remove_import(self): r = self._rand() if self._skip: return imps = list(self._suite.imports) if imps: i = int(r * len(imps)) print 'suite.imports.execute(DeleteItem(%d))' % i self._suite.imports.execute(DeleteItem(i)) def add_resource_import(self): if not self._skip: print 'suite.imports.execute(AddResource(["SomeNonExisting.txt"], "#comment"))' self._suite.imports.execute( AddResource(['SomeNonExisting.txt'], '#comment')) def change_import_order(self): self._change_order(range(sum(1 for _ in self._suite.imports)), self._suite.imports) def rename_keyword(self): class Observer(object): def notify(self, *args): pass def finish(self, *args): pass self._macro_execute(RenameKeywordOccurrences('foo', 'bar', Observer())) def rename_test(self): if self._skip: self._rand() return self._test.execute(RenameTest('new_name%s' % str(self._rand()))) def undo(self): self._macro_execute(Undo()) def redo(self): self._macro_execute(Redo()) def save(self): if self._skip: return command = SaveFile() print 'suite.execute(%s)' % str(command) self._suite.execute(command) def get_cell_info(self): macro = self._random.choice( [c for c in [self._test, self._keyword] if c]) row = self._rand_row() col = self._rand_col() if self._skip: return print '%s.get_cell_info(%s, %s)' % (self._name(macro), row, col) macro.get_cell_info(row, col)
class RIDE(wx.App): def __init__(self, path=None, updatecheck=True): self._initial_path = path self._updatecheck = updatecheck context.APP = self wx.App.__init__(self, redirect=False) def OnInit(self): # Needed for SetToolTipString to work wx.HelpProvider.Set(wx.SimpleHelpProvider()) # TODO adjust to wx versions self.settings = RideSettings() librarydatabase.initialize_database() self.preferences = Preferences(self.settings) self.namespace = Namespace(self.settings) self._controller = Project(self.namespace, self.settings) self.frame = RideFrame(self, self._controller) self._editor_provider = EditorProvider() self._plugin_loader = PluginLoader(self, self._get_plugin_dirs(), coreplugins.get_core_plugins()) self._plugin_loader.enable_plugins() self.frame.Show() self.editor = self._get_editor() self._load_data() self.frame.tree.populate(self.model) self.frame.tree.set_editor(self.editor) self._find_robot_installation() self._publish_system_info() if self._updatecheck: UpdateNotifierController( self.settings).notify_update_if_needed(UpdateDialog) wx.CallLater(200, ReleaseNotes(self).bring_to_front) return True def _publish_system_info(self): publish.RideLogMessage(context.SYSTEM_INFO).publish() @property def model(self): return self._controller def _get_plugin_dirs(self): return [self.settings.get_path('plugins'), os.path.join(self.settings['install root'], 'site-plugins'), contrib.CONTRIB_PATH] def _get_editor(self): from robotide.editor import EditorPlugin for pl in self._plugin_loader.plugins: maybe_editor = pl._plugin if isinstance(maybe_editor, EditorPlugin): maybe_editor.show() return maybe_editor def _load_data(self): path = self._initial_path or self._get_latest_path() if path: observer = LoadProgressObserver(self.frame) self._controller.load_data(path, observer) """ if path: with self.active_event_loop(): # observer = LoadProgressObserver(self.frame) observer = None # Avoid crash in Windows with wxPython 3 self._controller.load_data(path, observer) """ def _find_robot_installation(self): output = utils.run_python_command( ['import robot; print(robot.__file__ + \", \" + robot.__version__)']) if utils.PY2: robot_found = "ImportError" not in output and output else: robot_found = b"ModuleNotFoundError" not in output and output if robot_found: # print("DEBUG: output: %s strip: %s" % (output, output.strip().split(b", "))) rf_file, rf_version = output.strip().split(b", ") if utils.PY2: publish.RideLogMessage( "Found Robot Framework version %s from %s." % ( rf_version, os.path.dirname(rf_file))).publish() else: publish.RideLogMessage( "Found Robot Framework version %s from %s." % ( str(rf_version, 'utf-8'), str(os.path.dirname(rf_file), 'utf-8'))).publish() return rf_version else: publish.RideLogMessage( publish.get_html_message('no_robot'), notify_user=True ).publish() def _get_latest_path(self): recent = self._get_recentfiles_plugin() if not recent or not recent.recent_files: return None return recent.recent_files[0] def _get_recentfiles_plugin(self): from robotide.recentfiles import RecentFilesPlugin for pl in self.get_plugins(): if isinstance(pl._plugin, RecentFilesPlugin): return pl._plugin def get_plugins(self): return self._plugin_loader.plugins def register_preference_panel(self, panel_class): '''Add the given panel class to the list of known preference panels''' self.preferences.add(panel_class) def unregister_preference_panel(self, panel_class): '''Remove the given panel class from the known preference panels''' self.preferences.remove(panel_class) def register_editor(self, object_class, editor_class, activate): self._editor_provider.register_editor(object_class, editor_class, activate) def unregister_editor(self, object_class, editor_class): self._editor_provider.unregister_editor(object_class, editor_class) def activate_editor(self, object_class, editor_class): self._editor_provider.set_active_editor(object_class, editor_class) def get_editors(self, object_class): return self._editor_provider.get_editors(object_class) def get_editor(self, object_class): return self._editor_provider.get_editor(object_class) @contextmanager def active_event_loop(self): # With wxPython 2.9.1, ProgressBar.Pulse breaks if there's no active # event loop. # See http://code.google.com/p/robotframework-ride/issues/detail?id=798 loop = wx.EventLoop() wx.EventLoop.SetActive(loop) yield del loop
class RIDE(object): def __init__(self, random, path): print "librarydatabase.initialize_database()" print librarydatabase.initialize_database() print "settings = RideSettings()" print "project = Project(Namespace(settings=settings), settings=settings)" settings = RideSettings() self._project = Project(Namespace(settings=settings), settings=settings) self._path = path self._suite = None self._test = None self._keyword = None self._random = random self._skip = False def _skip_until_notified(self): self._skip = True def _do_not_skip(self): self._skip = False def open_test_dir(self): if self._skip: return self._open(os.path.join(self._path, "testdir")) print "suite = project.data.children[0]" self._suite = self._project.data.children[0] print "test = list(t for t in suite.tests)[0]" self._test = list(t for t in self._suite.tests)[0] print "keyword = list(k for k in suite.keywords)[0]" self._keyword = list(k for k in self._suite.keywords)[0] def open_suite_file(self): if self._skip: return self._open(os.path.join(self._path, "testdir", "Suite.txt")) print "suite = project.data" self._suite = self._project.data print "test = list(t for t in suite.tests)[0]" self._test = list(t for t in self._suite.tests)[0] print "keyword = list(k for k in suite.keywords)[0]" self._keyword = list(k for k in self._suite.keywords)[0] def _open_resource_file(self): self._open(os.path.join(self._path, "testdir", "resources", "resu.txt")) self._suite = None self._test = None self._keyword = None def _open(self, path): print 'project.load_data("%s", NullObserver())' % path self._project.load_data(path, NullObserver()) def _create_suite(self): filename = os.path.join(self._path, "path_to_foo%s.txt" % str(self._rand())) print 'suite = project.data.execute(AddSuite(NewDatafile("%s")))' % filename self._suite = self._project.data.execute(AddTestCaseFile(filename)) def create_test(self): if self._skip: self._rand() return testname = "foobar" + str(self._rand()) print 'test = suite.execute(AddTestCase("%s"))' % testname self._test = self._suite.execute(AddTestCase(testname)) def change_test_order(self): self._change_order([t.data for t in self._suite.tests], self._suite.tests) def _change_order(self, items, controller): command = MoveUp if self._rand() > 0.5 else MoveDown r = self._rand() if self._skip: return items = list(items) if items: i = int(r * (len(items))) print "%s.execute(%s(items[%d]))" % (controller.__class__.__name__, command.__name__, i) controller.execute(command(items[i])) def _rand(self): return self._random.random() def _rand_row(self): return self._random.randint(0, 100) def _rand_col(self): return self._random.randint(0, 30) def create_keyword(self): if self._skip: self._rand() return keyword_name = "kwFoobar" + str(self._rand()) print 'keyword = suite.execute(AddKeyword("%s"))' % keyword_name self._keyword = self._suite.execute(AddKeyword(keyword_name)) def change_keyword_order(self): pass def add_variable(self): if self._skip: self._rand() self._rand() return command = AddVariable("${var%s}" % str(self._rand()), str(self._rand()), "comment") print "suite.execute(%s)" % str(command) self._suite.execute(command) def change_variable_order(self): pass def write_cell_data(self): value = self._random.choice( [ "# something", "foobar", ": FOR", "${var}", "No Operation", "\\", "zoo%d" % self._rand(), "${%d}" % self._rand(), ] ) self._macro_execute(ChangeCellValue(self._rand_row(), self._rand_col(), value)) def write_for_loop(self): self._macro_execute( InsertArea((self._rand_row(), 0), [[":FOR", "${i}", "IN", "1", "2", "foo"], ["", "No Operation"]]) ) def _macro_execute(self, command): macro = self._random.choice([c for c in [self._test, self._keyword] if c]) if not self._skip: print "%s.execute(%s)" % (self._name(macro), str(command)) macro.execute(command) def _name(self, macro): if macro == self._test: return "test" return "keyword" def add_row(self): self._macro_execute(AddRow(self._rand_row())) def remove_row(self): self._macro_execute(DeleteRow(self._rand_row())) def add_cell(self): self._macro_execute(InsertCell(self._rand_row(), self._rand_col())) def remove_cell(self): self._macro_execute(DeleteCell(self._rand_row(), self._rand_col())) def move_row_up(self): self._macro_execute(MoveRowsUp([self._rand_row()])) def move_row_down(self): self._macro_execute(MoveRowsDown([self._rand_row()])) def extract_keyword(self): first_row = self._rand_row() self._macro_execute(ExtractKeyword("foo", "", [first_row, first_row + self._random.randint(1, 10)])) def add_library_import(self): if not self._skip: print 'suite.imports.execute(AddLibrary(["OperatingSystem", "", ""], "#comment"))' self._suite.imports.execute(AddLibrary(["OperatingSystem", "", ""], "#comment")) def remove_import(self): r = self._rand() if self._skip: return imps = list(self._suite.imports) if imps: i = int(r * len(imps)) print "suite.imports.execute(DeleteItem(%d))" % i self._suite.imports.execute(DeleteItem(i)) def add_resource_import(self): if not self._skip: print 'suite.imports.execute(AddResource(["SomeNonExisting.txt"], "#comment"))' self._suite.imports.execute(AddResource(["SomeNonExisting.txt"], "#comment")) def change_import_order(self): self._change_order(range(sum(1 for _ in self._suite.imports)), self._suite.imports) def rename_keyword(self): class Observer(object): def notify(self, *args): pass def finish(self, *args): pass self._macro_execute(RenameKeywordOccurrences("foo", "bar", Observer())) def rename_test(self): if self._skip: self._rand() return self._test.execute(RenameTest("new_name%s" % str(self._rand()))) def undo(self): self._macro_execute(Undo()) def redo(self): self._macro_execute(Redo()) def save(self): if self._skip: return command = SaveFile() print "suite.execute(%s)" % str(command) self._suite.execute(command) def get_cell_info(self): macro = self._random.choice([c for c in [self._test, self._keyword] if c]) row = self._rand_row() col = self._rand_col() if self._skip: return print "%s.get_cell_info(%s, %s)" % (self._name(macro), row, col) macro.get_cell_info(row, col)
class RIDE(object): def __init__(self, random, path): print('librarydatabase.initialize_database()') print(librarydatabase.initialize_database()) print('settings = RideSettings()') print('project = Project(Namespace(settings=settings),' ' settings=settings)') settings = RideSettings() self._project = Project(Namespace(settings=settings), settings=settings) self._path = path self._suite = None self._test = None self._keyword = None self._random = random self._skip = False def _skip_until_notified(self): self._skip = True def _do_not_skip(self): self._skip = False def open_test_dir(self): if self._skip: return self._open(os.path.join(self._path, 'testdir')) print('suite = project.data.children[0]') self._suite = self._project.data.children[0] print('test = list(t for t in suite.tests)[0]') self._test = list(t for t in self._suite.tests)[0] print('keyword = list(k for k in suite.keywords)[0]') self._keyword = list(k for k in self._suite.keywords)[0] def open_suite_file(self): if self._skip: return self._open(os.path.join(self._path, 'testdir', 'Suite.txt')) print('suite = project.data') self._suite = self._project.data print('test = list(t for t in suite.tests)[0]') self._test = list(t for t in self._suite.tests)[0] print('keyword = list(k for k in suite.keywords)[0]') self._keyword = list(k for k in self._suite.keywords)[0] def _open_resource_file(self): self._open(os.path.join(self._path, 'testdir', 'resources', 'resu.txt')) self._suite = None self._test = None self._keyword = None def _open(self, path): print('project.load_data("%s", NullObserver())' % path) self._project.load_data(path, NullObserver()) def _create_suite(self): filename = os.path.join(self._path,'path_to_foo%s.txt' % str(self._rand())) print('suite = project.data.execute(AddSuite(NewDatafile("%s")))' % filename) self._suite = self._project.data.execute(AddTestCaseFile(filename)) def create_test(self): if self._skip: self._rand() return testname = 'foobar'+str(self._rand()) print('test = suite.execute(AddTestCase("%s"))' % testname) self._test = self._suite.execute(AddTestCase(testname)) def change_test_order(self): self._change_order([t.data for t in self._suite.tests], self._suite.tests) def _change_order(self, items, controller): command = MoveUp if self._rand() > 0.5 else MoveDown r = self._rand() if self._skip: return items = list(items) if items: i = int(r*(len(items))) print('%s.execute(%s(items[%d]))' % (controller.__class__.__name__, command.__name__, i)) controller.execute(command(items[i])) def _rand(self): return self._random.random() def _rand_row(self): return self._random.randint(0,100) def _rand_col(self): return self._random.randint(0, 30) def create_keyword(self): if self._skip: self._rand() return keyword_name = 'kwFoobar'+str(self._rand()) print('keyword = suite.execute(AddKeyword("%s"))' % keyword_name) self._keyword = self._suite.execute(AddKeyword(keyword_name)) def change_keyword_order(self): pass def add_variable(self): if self._skip: self._rand() self._rand() return command = AddVariable('${var%s}' % str(self._rand()), str(self._rand()), 'comment') print('suite.execute(%s)' % str(command)) self._suite.execute(command) def change_variable_order(self): pass def write_cell_data(self): value = self._random.choice(['# something', 'foobar', ': FOR', '${var}', 'No Operation', '\\', 'zoo%d' % self._rand(), '${%d}' % self._rand()]) self._macro_execute(ChangeCellValue(self._rand_row(), self._rand_col(), value)) def write_for_loop(self): self._macro_execute(InsertArea((self._rand_row(), 0), [[':FOR', '${i}', 'IN', '1', '2', 'foo'], ['', 'No Operation']])) def _macro_execute(self, command): macro = self._random.choice([c for c in [self._test, self._keyword] if c]) if not self._skip: print('%s.execute(%s)' % (self._name(macro), str(command))) macro.execute(command) def _name(self, macro): if macro == self._test: return 'test' return 'keyword' def add_row(self): self._macro_execute(AddRow(self._rand_row())) def remove_row(self): self._macro_execute(DeleteRow(self._rand_row())) def add_cell(self): self._macro_execute(InsertCell(self._rand_row(), self._rand_col())) def remove_cell(self): self._macro_execute(DeleteCell(self._rand_row(), self._rand_col())) def move_row_up(self): self._macro_execute(MoveRowsUp([self._rand_row()])) def move_row_down(self): self._macro_execute(MoveRowsDown([self._rand_row()])) def extract_keyword(self): first_row = self._rand_row() self._macro_execute(ExtractKeyword('foo', '', [first_row, first_row+ self._random.randint(1,10)])) def add_library_import(self): if not self._skip: print('suite.imports.execute(AddLibrary(' '["OperatingSystem", "", ""], "#comment"))') self._suite.imports.execute(AddLibrary(['OperatingSystem', '', ''], '#comment')) def remove_import(self): r = self._rand() if self._skip: return imps = list(self._suite.imports) if imps: i = int(r*len(imps)) print('suite.imports.execute(DeleteItem(%d))' % i) self._suite.imports.execute(DeleteItem(i)) def add_resource_import(self): if not self._skip: print('suite.imports.execute(AddResource(["SomeNonExisting.txt"],' ' "#comment"))') self._suite.imports.execute(AddResource(['SomeNonExisting.txt'], '#comment')) def change_import_order(self): self._change_order(range(sum(1 for _ in self._suite.imports)), self._suite.imports) def rename_keyword(self): class Observer(object): def notify(self, *args): pass def finish(self, *args): pass self._macro_execute(RenameKeywordOccurrences('foo', 'bar', Observer())) def rename_test(self): if self._skip: self._rand() return self._test.execute(RenameTest('new_name%s' % str(self._rand()))) def undo(self): self._macro_execute(Undo()) def redo(self): self._macro_execute(Redo()) def save(self): if self._skip: return command = SaveFile() print('suite.execute(%s)' % str(command)) self._suite.execute(command) def get_cell_info(self): macro = self._random.choice([c for c in [self._test, self._keyword] if c]) row = self._rand_row() col = self._rand_col() if self._skip: return print('%s.get_cell_info(%s, %s)' % (self._name(macro), row, col)) macro.get_cell_info(row, col)