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 setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library('somelib', ['foo', 'bar'])
self.tcf.setting_table.add_resource('resu')
self.tcf.setting_table.add_library('BuiltIn', ['WITH NAME', 'InBuilt'])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = 'tmp'
self.parent = ImportSettingsController(self.tcf_ctrl, self.tcf.setting_table)
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library("somelib", ["foo", "bar"])
self.tcf.setting_table.add_resource("resu")
self.tcf.setting_table.add_library("BuiltIn", ["WITH NAME", "InBuilt"])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = "tmp"
self.parent = ImportSettingsController(
self.tcf_ctrl,
self.tcf.setting_table,
resource_file_controller_factory=self._resource_file_controller_factory_mock(),
)
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library('somelib', ['foo', 'bar'])
self.tcf.setting_table.add_resource('resu')
self.tcf.setting_table.add_library('BuiltIn', ['WITH NAME', 'InBuilt'])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = 'tmp'
self.parent = ImportSettingsController(self.tcf_ctrl, self.tcf.setting_table,
resource_file_controller_factory=self._resource_file_controller_factory_mock())
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
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)
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)
class ImportControllerTest(unittest.TestCase):
class FakeParent(_FakeChief):
_namespace = None
@property
def directory(self):
return 'tmp'
def resource_import_modified(self, path, directory):
pass
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library('somelib', ['foo', 'bar'])
self.tcf.setting_table.add_resource('resu')
self.tcf.setting_table.add_library('BuiltIn', ['WITH NAME', 'InBuilt'])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = 'tmp'
self.parent = ImportSettingsController(self.tcf_ctrl, self.tcf.setting_table)
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
def tearDown(self):
self.add_import_listener.unsubscribe()
self.changed_import_listener.unsubscribe()
self.import_listener.unsubscribe()
def test_creation(self):
self._assert_import(0, 'somelib', ['foo', 'bar'])
self._assert_import(1, 'resu')
self._assert_import(2, 'BuiltIn', exp_alias='InBuilt')
def test_display_value(self):
assert_equals(self.parent[0].display_value, 'foo | bar')
assert_equals(self.parent[1].display_value, '')
assert_equals(self.parent[2].display_value, 'WITH NAME | InBuilt')
def test_editing(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value('foo')
self._assert_import(1, 'foo')
assert_true(self.parent.dirty)
def test_editing_with_args(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value('bar', 'quux')
self._assert_import(0, 'bar', ['quux'])
assert_true(self.parent.dirty)
ctrl.set_value('name', 'a1 | a2')
self._assert_import(0, 'name', ['a1', 'a2'])
def test_editing_with_alias(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value('newname', '', 'namenew')
self._assert_import(0, 'newname', exp_alias='namenew')
ctrl.set_value('again')
self._assert_import(0, 'again')
def test_publishing_change(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value('new name')
self._test_listener('new name', 'resource', self.changed_import_listener)
def test_publishing_remove(self):
self.parent.delete(1)
self._test_listener('resu', 'resource', self.removed_import_listener)
self.parent.delete(0)
self._test_listener('somelib', 'library', self.removed_import_listener, 1)
def test_publish_adding_library(self):
self.parent.add_library('name', 'argstr', None)
self._test_listener('name', 'library', self.add_import_listener)
def test_publish_adding_resource(self):
self.parent.add_resource('path')
self._test_listener('path', 'resource', self.add_import_listener)
def test_publish_adding_variables(self):
self.parent.add_variables('path', 'argstr')
self._test_listener('path', 'variables', self.add_import_listener)
def _test_listener(self, name, type, listener, index=0):
data = listener.data[index]
assert_equals(data.name, name)
assert_equals(data.type, type)
assert_equals(data.datafile, self.tcf_ctrl)
assert_equals(self.import_listener.data[index].name, name)
def _assert_import(self, index, exp_name, exp_args=[], exp_alias=''):
item = self.parent[index]
assert_equals(item.name, exp_name)
assert_equals(item.args, exp_args)
assert_equals(item.alias, exp_alias)
def setUp(self):
self.ctrl = ChiefController(Namespace())
self.load_observer = MessageRecordingLoadObserver()
self.suite_listener = PublisherListener(RideOpenSuite)
self.resource_listener = PublisherListener(RideOpenResource)
class ChiefControllerTest(unittest.TestCase):
def setUp(self):
self.ctrl = ChiefController(Namespace())
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()
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):
assert_equals(self._get_paths(self.suite_listener.data), suite_paths)
assert_equals(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_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):
chief = datafilereader.construct_chief_controller(RESOURCE_PATH)
all_kws = chief.get_all_keywords()
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 ImportControllerTest(unittest.TestCase):
class FakeParent(_FakeProject):
_namespace = None
@property
def directory(self):
return 'tmp'
def resource_import_modified(self, path, directory):
pass
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library('somelib', ['foo', 'bar'])
self.tcf.setting_table.add_resource('resu')
self.tcf.setting_table.add_library('BuiltIn', ['WITH NAME', 'InBuilt'])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = 'tmp'
self.parent = ImportSettingsController(self.tcf_ctrl, self.tcf.setting_table,
resource_file_controller_factory=self._resource_file_controller_factory_mock())
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
def _resource_file_controller_factory_mock(self):
rfcfm = lambda:0
rfcfm.find_with_import = lambda *_:None
return rfcfm
def tearDown(self):
self.add_import_listener.unsubscribe()
self.changed_import_listener.unsubscribe()
self.import_listener.unsubscribe()
def test_creation(self):
self._assert_import(0, 'somelib', ['foo', 'bar'])
self._assert_import(1, 'resu')
self._assert_import(2, 'BuiltIn', exp_alias='InBuilt')
def test_display_value(self):
assert_equals(self.parent[0].display_value, 'foo | bar')
assert_equals(self.parent[1].display_value, '')
assert_equals(self.parent[2].display_value, 'WITH NAME | InBuilt')
def test_editing(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value('foo')
self._assert_import(1, 'foo')
assert_true(self.parent.dirty)
def test_editing_with_args(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value('bar', 'quux')
self._assert_import(0, 'bar', ['quux'])
assert_true(self.parent.dirty)
ctrl.set_value('name', 'a1 | a2')
self._assert_import(0, 'name', ['a1', 'a2'])
def test_editing_with_alias(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value('newname', '', 'namenew')
self._assert_import(0, 'newname', exp_alias='namenew')
ctrl.set_value('again')
self._assert_import(0, 'again')
def test_publishing_change(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value('new name')
self._test_listener('new name', 'resource', self.changed_import_listener)
def test_publishing_remove(self):
self.parent.delete(1)
self._test_listener('resu', 'resource', self.removed_import_listener)
self.parent.delete(0)
self._test_listener('somelib', 'library', self.removed_import_listener, 1)
def test_publish_adding_library(self):
self.parent.add_library('name', 'argstr', None)
self._test_listener('name', 'library', self.add_import_listener)
def test_publish_adding_resource(self):
self.parent.add_resource('path')
self._test_listener('path', 'resource', self.add_import_listener)
def test_publish_adding_variables(self):
self.parent.add_variables('path', 'argstr')
self._test_listener('path', 'variables', self.add_import_listener)
def _test_listener(self, name, type, listener, index=0):
data = listener.data[index]
assert_equals(data.name, name)
assert_equals(data.type, type)
assert_equals(data.datafile, self.tcf_ctrl)
assert_equals(self.import_listener.data[index].name, name)
def _assert_import(self, index, exp_name, exp_args=[], exp_alias=''):
item = self.parent[index]
assert_equals(item.name, exp_name)
assert_equals(item.args, exp_args)
assert_equals(item.alias, exp_alias)
class ImportControllerTest(unittest.TestCase):
class FakeParent(_FakeProject):
_namespace = None
@property
def directory(self):
return "tmp"
def resource_import_modified(self, path, directory):
pass
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_library("somelib", ["foo", "bar"])
self.tcf.setting_table.add_resource("resu")
self.tcf.setting_table.add_library("BuiltIn", ["WITH NAME", "InBuilt"])
self.tcf_ctrl = TestCaseFileController(self.tcf, ImportControllerTest.FakeParent())
self.tcf_ctrl.data.directory = "tmp"
self.parent = ImportSettingsController(
self.tcf_ctrl,
self.tcf.setting_table,
resource_file_controller_factory=self._resource_file_controller_factory_mock(),
)
self.add_import_listener = PublisherListener(RideImportSettingAdded)
self.changed_import_listener = PublisherListener(RideImportSettingChanged)
self.removed_import_listener = PublisherListener(RideImportSettingRemoved)
self.import_listener = PublisherListener(RideImportSetting)
def _resource_file_controller_factory_mock(self):
rfcfm = lambda: 0
rfcfm.find_with_import = lambda *_: None
return rfcfm
def tearDown(self):
self.add_import_listener.unsubscribe()
self.changed_import_listener.unsubscribe()
self.import_listener.unsubscribe()
def test_creation(self):
self._assert_import(0, "somelib", ["foo", "bar"])
self._assert_import(1, "resu")
self._assert_import(2, "BuiltIn", exp_alias="InBuilt")
def test_display_value(self):
assert_equals(self.parent[0].display_value, "foo | bar")
assert_equals(self.parent[1].display_value, "")
assert_equals(self.parent[2].display_value, "WITH NAME | InBuilt")
def test_editing(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value("foo")
self._assert_import(1, "foo")
assert_true(self.parent.dirty)
def test_editing_with_args(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value("bar", "quux")
self._assert_import(0, "bar", ["quux"])
assert_true(self.parent.dirty)
ctrl.set_value("name", "a1 | a2")
self._assert_import(0, "name", ["a1", "a2"])
def test_editing_with_alias(self):
ctrl = ImportController(self.parent, self.parent[0]._import)
ctrl.set_value("newname", "", "namenew")
self._assert_import(0, "newname", exp_alias="namenew")
ctrl.set_value("again")
self._assert_import(0, "again")
def test_publishing_change(self):
ctrl = ImportController(self.parent, self.parent[1]._import)
ctrl.set_value("new name")
self._test_listener("new name", "resource", self.changed_import_listener)
def test_publishing_remove(self):
self.parent.delete(1)
self._test_listener("resu", "resource", self.removed_import_listener)
self.parent.delete(0)
self._test_listener("somelib", "library", self.removed_import_listener, 1)
def test_publish_adding_library(self):
self.parent.add_library("name", "argstr", None)
self._test_listener("name", "library", self.add_import_listener)
def test_publish_adding_resource(self):
self.parent.add_resource("path")
self._test_listener("path", "resource", self.add_import_listener)
def test_publish_adding_variables(self):
self.parent.add_variables("path", "argstr")
self._test_listener("path", "variables", self.add_import_listener)
def _test_listener(self, name, type, listener, index=0):
data = listener.data[index]
assert_equals(data.name, name)
assert_equals(data.type, type)
assert_equals(data.datafile, self.tcf_ctrl)
assert_equals(self.import_listener.data[index].name, name)
def _assert_import(self, index, exp_name, exp_args=[], exp_alias=""):
item = self.parent[index]
assert_equals(item.name, exp_name)
assert_equals(item.args, exp_args)
assert_equals(item.alias, exp_alias)
