def TestCaseControllerWithSteps(project=None, source='some_suite.txt'): tcf = TestCaseFile() tcf.source = source tcf.setting_table.suite_setup.name = 'Suite Setup Kw' tcf.setting_table.test_setup.name = SUITE_TEST_SETUP_KEYWORD tcf.setting_table.test_teardown.name = 'Test Teardown Kw' tcf.setting_table.suite_teardown.name = 'Suite Teardown Kw' tcf.setting_table.test_template.value = SUITE_TEST_TEMPLATE_KEYWORD testcase = _create_testcase(tcf) uk = tcf.keyword_table.add(USERKEYWORD1_NAME) uk.add_step([KEYWORD_IN_USERKEYWORD1]) uk = tcf.keyword_table.add(USERKEYWORD2_NAME) uk.add_step(['No Operation']) uk = tcf.keyword_table.add(EMBEDDED_ARGUMENTS_KEYWORD) uk.add_step(['No Operation']) if project is None: library_manager = LibraryManager(':memory:') library_manager.create_database() project = Project(Namespace(FakeSettings()), library_manager=library_manager) tcf_ctrl = TestCaseFileController(tcf, project) project._controller = tcf_ctrl tctablectrl = TestCaseTableController(tcf_ctrl, tcf.testcase_table) return TestCaseController(tctablectrl, testcase), project._namespace
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 __init__(self, namespace, settings=None, library_manager=None): self.removed_files = [] self.serialized_files = [] library_manager = library_manager or LibraryManager(':memory:') if not library_manager: library_manager.create_database() Project.__init__(self, namespace, settings, library_manager)
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 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 _load(self, testcasefile): ns = Namespace(FakeSettings()) library_manager = LibraryManager(":memory:") library_manager.create_database() project = Project(ns, settings=ns._settings, library_manager=library_manager) project.load_datafile(testcasefile, MessageRecordingLoadObserver()) return ns, project._controller.data, library_manager
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 _load(self, testcasefile): ns = Namespace(FakeSettings()) library_manager = LibraryManager(':memory:') library_manager.create_database() project = Project(ns, settings=ns._settings, library_manager=library_manager) project.load_datafile(testcasefile, MessageRecordingLoadObserver()) return ns, project._controller.data, library_manager
class TestFindingControllers(unittest.TestCase): def setUp(self): self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager()) def tearDown(self): self.project.close() def test_finding_root_directory_controller(self): self.project._controller = TestDataDirectoryController(_data_directory('Root')) result = self.project.find_controller_by_longname('Root') assert_equal(result, self.project._controller) def test_finding_subdirectory_controller(self): directory_controller = TestDataDirectoryController(_data_directory('Root')) subdirectory_controller = TestDataDirectoryController(_data_directory('Sub.suite')) directory_controller.add_child(subdirectory_controller) self.project._controller = directory_controller result = self.project.find_controller_by_longname('Root.Sub.suite') assert_equal(result, subdirectory_controller) def test_finding_testcase_controller(self): suite_controller = TestCaseFileController(_testcasefile('Suite.txt')) test = suite_controller.create_test('Test 1') self.project._controller = suite_controller result = self.project.find_controller_by_longname('Suite.Test 1', 'Test 1') assert_equal(result, test) def test_finding_correct_testcase_when_two_with_same_name(self): test1, test2 = self._create_suite_structure_with_two_tests_with_same_name() result1 = self.project.find_controller_by_longname('Ro.ot.' + test1.longname, test1.display_name) assert_equal(result1, test1) result2 = self.project.find_controller_by_longname('Ro.ot.' + test2.longname, test2.display_name) assert_equal(result2, test2) def test_finding_correct_testcase_when_two_files_with_same_name_start(self): directory_controller = TestDataDirectoryController(_data_directory('t')) suite1_controller = TestCaseFileController(_testcasefile('test.txt')) test1 = suite1_controller.create_test('A') suite2_controller = TestCaseFileController(_testcasefile('test2.txt')) test2 = suite2_controller.create_test('A') directory_controller.add_child(suite1_controller) directory_controller.add_child(suite2_controller) self.project._controller = directory_controller result1 = self.project.find_controller_by_longname('T.' + test1.longname, test1.display_name) assert_equal(result1, test1) result2 = self.project.find_controller_by_longname('T.' + test2.longname, test2.display_name) assert_equal(result2, test2) def _create_suite_structure_with_two_tests_with_same_name(self): directory_controller = TestDataDirectoryController(_data_directory('Ro.ot')) suite1_controller = TestCaseFileController(_testcasefile('Suite.1.txt')) test1 = suite1_controller.create_test('Te.st') suite2_controller = TestCaseFileController(_testcasefile('Suite.2.txt')) test2 = suite2_controller.create_test('Te.st') directory_controller.add_child(suite1_controller) directory_controller.add_child(suite2_controller) self.project._controller = directory_controller return test1, test2
class TestFindingControllers(unittest.TestCase): def setUp(self): self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager()) def tearDown(self): self.project.close() def test_finding_root_directory_controller(self): self.project._controller = TestDataDirectoryController(_data_directory('Root')) result = self.project.find_controller_by_longname('Root') assert_equals(result, self.project._controller) def test_finding_subdirectory_controller(self): directory_controller = TestDataDirectoryController(_data_directory('Root')) subdirectory_controller = TestDataDirectoryController(_data_directory('Sub.suite')) directory_controller.add_child(subdirectory_controller) self.project._controller = directory_controller result = self.project.find_controller_by_longname('Root.Sub.suite') assert_equals(result, subdirectory_controller) def test_finding_testcase_controller(self): suite_controller = TestCaseFileController(_testcasefile('Suite.txt')) test = suite_controller.create_test('Test 1') self.project._controller = suite_controller result = self.project.find_controller_by_longname('Suite.Test 1', 'Test 1') assert_equals(result, test) def test_finding_correct_testcase_when_two_with_same_name(self): test1, test2 = self._create_suite_structure_with_two_tests_with_same_name() result1 = self.project.find_controller_by_longname('Ro.ot.'+test1.longname, test1.display_name) assert_equals(result1, test1) result2 = self.project.find_controller_by_longname('Ro.ot.'+test2.longname, test2.display_name) assert_equals(result2, test2) def test_finding_correct_testcase_when_two_files_with_same_name_start(self): directory_controller = TestDataDirectoryController(_data_directory('t')) suite1_controller = TestCaseFileController(_testcasefile('test.txt')) test1 = suite1_controller.create_test('A') suite2_controller = TestCaseFileController(_testcasefile('test2.txt')) test2 = suite2_controller.create_test('A') directory_controller.add_child(suite1_controller) directory_controller.add_child(suite2_controller) self.project._controller = directory_controller result1 = self.project.find_controller_by_longname('T.'+test1.longname, test1.display_name) assert_equals(result1, test1) result2 = self.project.find_controller_by_longname('T.'+test2.longname, test2.display_name) assert_equals(result2, test2) def _create_suite_structure_with_two_tests_with_same_name(self): directory_controller = TestDataDirectoryController(_data_directory('Ro.ot')) suite1_controller = TestCaseFileController(_testcasefile('Suite.1.txt')) test1 = suite1_controller.create_test('Te.st') suite2_controller = TestCaseFileController(_testcasefile('Suite.2.txt')) test2 = suite2_controller.create_test('Te.st') directory_controller.add_child(suite1_controller) directory_controller.add_child(suite2_controller) self.project._controller = directory_controller return test1, test2
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
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 OnInit(self): # DEBUG To test RTL # self._initial_locale = wx.Locale(wx.LANGUAGE_ARABIC) self._initial_locale = wx.Locale(wx.LANGUAGE_ENGLISH) # 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.treeplugin = TreePlugin(self) self.treeplugin.register_frame(self.frame) self.fileexplorerplugin = FileExplorerPlugin(self, self._controller) self.fileexplorerplugin.register_frame(self.frame) self.frame.Show() if not self.treeplugin.opened: self.treeplugin.close_tree() if not self.fileexplorerplugin.opened: self.fileexplorerplugin.close_tree() self.editor = self._get_editor() self._load_data() self.treeplugin.populate(self.model) self.treeplugin.set_editor(self.editor) self._find_robot_installation() self._publish_system_info() perspective = self.settings.get('AUI Perspective', None) if perspective: self.frame._mgr.LoadPerspective(perspective, True) if self._updatecheck: UpdateNotifierController( self.settings).notify_update_if_needed(UpdateDialog) wx.CallLater(200, ReleaseNotes(self).bring_to_front) wx.CallLater(200, self.fileexplorerplugin._update_tree) return True
def OnInit(self): 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(), context.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 __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 _create_data(self, resource_name, resource_import): res_path = os.path.abspath(resource_name) tcf = TestCaseFile(source=os.path.abspath('test.txt')) tcf.setting_table.add_resource(resource_import) tcf.variable_table.add('${dirname}', os.path.abspath('.').replace('\\', '\\\\')) tcf.variable_table.add('${path}', os.path.abspath(resource_name).replace('\\', '\\\\')) library_manager = LibraryManager(':memory:') library_manager.create_database() self.project = Project(Namespace(FakeSettings()), FakeSettings(), library_manager) self.project._controller = TestCaseFileController(tcf, self.project) res = ResourceFile(source=res_path) self.res_controller = \ self.project._resource_file_controller_factory.create(res) self.project._namespace._resource_factory.cache[os.path.normcase(res_path)] = res
def setUp(self): self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager())
class TestResolvingResourceDirectories(unittest.TestCase): def setUp(self): self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager()) def tearDown(self): self.project.close() def test_resource_file_outside_of_topsuite_is_an_external_resource(self): self._set_data_directory_controller('suite') self._set_resources(j('foo', 'resource.txt')) assert_equal(self.project.external_resources, self.project.resources) def _set_data_directory_controller(self, dir): self.project._controller = TestDataDirectoryController( _data_directory(dir)) def test_resource_file_in_own_directory_is_added_to_top_suite(self): self._set_data_directory_controller('foo') self._set_resources(j('foo', 'bar', 'quux.txt')) self._assert_resource_dir_was_created_as_child_of(self.project.data) self._assert_resource_dir_contains_resources() assert_true(len(self.project.external_resources) == 0) def test_two_resource_in_same_directory_get_same_parent(self): self._set_data_directory_controller('foo') self._set_resources(j('foo', 'bar', 'quux.txt'), j('foo', 'bar', 'zap.txt')) self._assert_resource_dir_was_created_as_child_of(self.project.data) self._assert_resource_dir_contains_resources() def test_two_nested_resources_in_same_directory_get_same_parent(self): self._set_data_directory_controller('suite') self._set_resources(j('suite', 'foo', 'bar', 'quux.txt'), j('suite', 'foo', 'bar', 'zap.txt')) assert_equal(self.project.data.children[0].children[0].children, self.project.resources) def test_resource_directory_gets_nearest_possible_parent(self): self._set_data_directory_controller('tmp') self.project.data.add_child( TestDataDirectoryController(_data_directory(j('tmp', 'some')))) self._set_resources(j('tmp', 'some', 'resoruces', 'res.txt')) assert_equal(len(self.project.data.children), 1) assert_equal(len(self.project.data.children[0].children), 1) assert_equal(self.project.data.children[0].children[0].children, [self.project.resources[0]]) def test_nested_resource_directories(self): self._set_data_directory_controller('tmp') self._set_resources(j('tmp', 'resoruces', 'res.txt'), j('tmp', 'resoruces', 'more', 'res.txt')) assert_equal(len(self.project.data.children), 1) assert_equal(len(self.project.data.children[0].children), 2) assert_equal(self.project.data.children[0].children[1].children, [self.project.resources[1]]) def test_resource_in_nested_directory(self): self._set_data_directory_controller('tmp') self._set_resources(j('tmp', 'res', 'ources', 'res.txt')) assert_equal(len(self.project.data.children), 1) assert_equal(len(self.project.data.children[0].children), 1) assert_equal(self.project.data.children[0].children[0].children, [self.project.resources[0]]) assert_true(len(self.project.external_resources) == 0) def _set_resources(self, *paths): for p in paths: resource = ResourceFileController(ResourceFile( os.path.normpath(p))) self.project.resources.append(resource) self.project.insert_into_suite_structure(resource) def _assert_resource_dir_was_created_as_child_of(self, ctrl): assert_equal(len(ctrl.children), 1) def _assert_resource_dir_contains_resources(self): assert_equal(self.project.data.children[0].children, self.project.resources)
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(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()) 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(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 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 TestResolvingResourceDirectories(unittest.TestCase): def setUp(self): self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager()) def tearDown(self): self.project.close() def test_resource_file_outside_of_topsuite_is_an_external_resource(self): self._set_data_directory_controller('suite') self._set_resources(j('foo','resource.txt')) assert_equals(self.project.external_resources, self.project.resources) def _set_data_directory_controller(self, dir): self.project._controller = TestDataDirectoryController(_data_directory(dir)) def test_resource_file_in_own_directory_is_added_to_top_suite(self): self._set_data_directory_controller('foo') self._set_resources(j('foo','bar','quux.txt')) self._assert_resource_dir_was_created_as_child_of(self.project.data) self._assert_resource_dir_contains_resources() assert_true(len(self.project.external_resources)== 0) def test_two_resource_in_same_directory_get_same_parent(self): self._set_data_directory_controller('foo') self._set_resources(j('foo','bar','quux.txt'), j('foo','bar','zap.txt')) self._assert_resource_dir_was_created_as_child_of(self.project.data) self._assert_resource_dir_contains_resources() def test_two_nested_resources_in_same_directory_get_same_parent(self): self._set_data_directory_controller('suite') self._set_resources(j('suite','foo','bar','quux.txt'), j('suite','foo','bar','zap.txt')) assert_equals(self.project.data.children[0].children[0].children, self.project.resources) def test_resource_directory_gets_nearest_possible_parent(self): self._set_data_directory_controller('tmp') self.project.data.add_child(TestDataDirectoryController(_data_directory(j('tmp','some')))) self._set_resources(j('tmp','some','resoruces','res.txt')) assert_equals(len(self.project.data.children), 1) assert_equals(len(self.project.data.children[0].children), 1) assert_equals(self.project.data.children[0].children[0].children, [self.project.resources[0]]) def test_nested_resource_directories(self): self._set_data_directory_controller('tmp') self._set_resources(j('tmp','resoruces','res.txt'), j('tmp','resoruces','more','res.txt')) assert_equals(len(self.project.data.children), 1) assert_equals(len(self.project.data.children[0].children), 2) assert_equals(self.project.data.children[0].children[1].children, [self.project.resources[1]]) def test_resource_in_nested_directory(self): self._set_data_directory_controller('tmp') self._set_resources(j('tmp','res','ources','res.txt')) assert_equals(len(self.project.data.children), 1) assert_equals(len(self.project.data.children[0].children), 1) assert_equals(self.project.data.children[0].children[0].children, [self.project.resources[0]]) assert_true(len(self.project.external_resources)== 0) def _set_resources(self, *paths): for p in paths: resource = ResourceFileController(ResourceFile(os.path.normpath(p))) self.project.resources.append(resource) self.project.insert_into_suite_structure(resource) def _assert_resource_dir_was_created_as_child_of(self, ctrl): assert_equals(len(ctrl.children), 1) def _assert_resource_dir_contains_resources(self): assert_equals(self.project.data.children[0].children, self.project.resources)
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
def create_project(): library_manager = LibraryManager(':memory:') library_manager.create_database() return Project(Namespace(FakeSettings()), FakeSettings(), library_manager)