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 __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 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 _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 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 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 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)
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)
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)
def setUp(self):
self.project = Project(Namespace(FakeSettings()), FakeSettings(), _library_manager())
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)
