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 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 _build_test_case_file():
tcf = TestCaseFile()
tcf.source = 'tmp.txt'
tcf.directory = '/tmp/'
_add_settings_table(tcf)
_add_variable_table(tcf)
_add_keyword_table(tcf)
return tcf
def _build_test_case_file():
tcf = TestCaseFile()
tcf.source = 'tmp.txt'
tcf.directory = '/tmp/'
_add_settings_table(tcf)
_add_variable_table(tcf)
_add_keyword_table(tcf)
return tcf
def create(data):
tcf = TestCaseFile()
tcf.directory = '/path/to'
pop = FromFilePopulator(tcf)
pop.start_table(['Test cases'])
for row in [ [cell for cell in line.split(' ')] for line in data]:
pop.add(row)
pop.eof()
return tcf
def create(data):
tcf = TestCaseFile()
tcf.directory = '/path/to'
pop = FromFilePopulator(tcf)
pop.start_table(['Test cases'])
for row in [[cell for cell in line.split(' ')] for line in data]:
pop.add(row)
pop.eof()
return tcf
def test_sort_and_restore_tests(self):
# Add tests
for test in ['Blabla', 'Atest', '2222222', '111111']:
new_test = TestCaseController(self.ctrl, TestCase(TestCaseFile(), test))
self.ctrl.add_test_or_keyword(new_test)
# Capture test list before sorting
original_tests = self.get_test_names()
list_for_undo_comparison = original_tests[:]
# Sort the list
self.ctrl.execute(SortTests())
sorted_tests = self.get_test_names()
original_tests.sort()
assert_equal(original_tests, sorted_tests)
# Undo sorting
self.ctrl.execute(Undo())
restored_list = self.get_test_names()
assert_equal(restored_list, list_for_undo_comparison)
# Redo sorting
self.ctrl.execute(Redo())
keywords_after_redo = self.get_test_names()
assert_equal(keywords_after_redo, sorted_tests)
def test_add_test_or_kw(self):
assert_equal(len(self.ctrl.tests), 0)
new_test = TestCaseController(self.ctrl, TestCase(TestCaseFile(), 'New test'))
self.ctrl.add_test_or_keyword(new_test)
assert_equal(len(self.ctrl.tests), 1)
assert_true(self.ctrl.tests[0]._test.parent.parent is self.ctrl.datafile)
assert_true(self.ctrl.dirty)
def test_overwrite(self):
ctrl = TestCaseFileController(TestCaseFile(source=self._filepath).populate(),
create_project())
os.utime(self._filepath, (1,1))
assert_true(ctrl.has_been_modified_on_disk())
ctrl.execute(SaveFile())
assert_false(ctrl.has_been_modified_on_disk())
def _create_test(self, name='test'):
suite = TestCaseFile(source='suite')
suite_controller = TestCaseFileController(suite)
parent = TestCaseTableController(suite_controller,
suite.testcase_table)
test = TestCase(parent=lambda: 0, name=name)
return TestCaseController(parent, test)
def test_find_suite_keywords(self):
everything_tcf = TestCaseFile(
source=TESTCASEFILE_WITH_EVERYTHING).populate()
all_kws = self.ns.get_all_keywords([self.tcf, everything_tcf])
self.assert_in_keywords(all_kws, 'Should be in keywords Uk',
'Copy List', 'Uk From Variable Resource')
self.assert_in_keywords(all_kws, 'My Test Setup', 'My Suite Teardown')
def test_deleting_source_should_remove_it_from_model(self):
project = create_project()
project._controller = TestCaseFileController(TestCaseFile(source=self._filepath), project)
os.remove(self._filepath)
ctrl = project.data
ctrl.remove()
assert_true(project.data is None)
assert_true(self._removed_datafile is ctrl)
def setUp(self):
self.tcf = TestCaseFile()
filectrl = TestCaseFileController(self.tcf)
filectrl.resource_import_modified = Mock()
resource_file_controller_mock = lambda:0
resource_file_controller_mock.add_known_import = lambda *_:0
resu_factory_mock = lambda:0
resu_factory_mock.find_with_import = lambda *_: resource_file_controller_mock
self.ctrl = ImportSettingsController(filectrl, self.tcf.setting_table, resu_factory_mock)
def setUp(self):
self.tcf = TestCaseFile()
uk = self.tcf.keyword_table.add('UK')
uk.add_step(['No Operation'])
uk2 = self.tcf.keyword_table.add('UK 2')
tablectrl = KeywordTableController(TestCaseFileController(self.tcf),
self.tcf.keyword_table)
self.ctrl = UserKeywordController(tablectrl, uk)
self.ctrl2 = UserKeywordController(tablectrl, uk2)
def test_is_user_keyword_in_resource_file(self):
everything_tcf = TestCaseFile(
source=TESTCASEFILE_WITH_EVERYTHING).populate()
assert_is_not_none(
self.ns.find_user_keyword(everything_tcf, 'Duplicate UK'))
assert_true(self.ns.is_user_keyword(everything_tcf, 'Duplicate UK'))
assert_is_not_none(
self.ns.find_user_keyword(everything_tcf, 'Another Resource UK'))
assert_true(
self.ns.is_user_keyword(everything_tcf, 'Another Resource UK'))
def setUp(self):
self.tcf = TestCaseFile()
self.testcase = self.tcf.testcase_table.add('Test')
self.testcase.add_step(['Log', 'Hello'])
self.testcase.add_step(['No Operation'])
self.testcase.add_step(['Foo'])
self.tcf.testcase_table.add('Another Test')
tctablectrl = TestCaseTableController(TestCaseFileController(self.tcf),
self.tcf.testcase_table)
self.ctrl = TestCaseController(tctablectrl, self.testcase)
def _create_controller(self, path='some.txt'):
self._filenames_to_remove.append(path)
self.ctrl = TestCaseFileController(TestCaseFile(source=path))
self.saved = False
self.deleted = False
self._message = None
self._error_message = None
def save(*args): self.saved = True
def remove_from_filesystem(*Args): self.deleted = True
self.ctrl.save = save
self.ctrl.remove_from_filesystem = remove_from_filesystem
return self.ctrl
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 test_reload(self):
controller_parent = object()
model_parent = object()
ctrl = TestCaseFileController(
TestCaseFile(parent=model_parent, source=self._filepath).populate(),
parent=controller_parent)
assert_equals(len(ctrl.tests), 1)
open(self._filepath, 'a').write('Second Test Log Hello World!\n')
ctrl.reload()
assert_equals(len(ctrl.tests), 2)
assert_equals(ctrl.tests[-1].name, 'Second Test')
assert_equals(ctrl.parent, controller_parent)
assert_equals(ctrl.data.parent, model_parent)
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
class TestCaseAndUserKeywordCopyingTest(unittest.TestCase):
controller = TestCaseFileController(
TestCaseFile(source=COMPLEX_SUITE_PATH).populate())
def test_test_case_copy(self):
test = self.controller.tests[0]
copy = test.copy('New Name')
assert_equal(copy.name, 'New Name')
for orig, copied in zip(test.settings, copy.settings):
assert_equal(orig.value, copied.value)
assert_true(copied is not orig)
assert_equal(test.steps, copy.steps)
assert_true(test.steps is not copy.steps)
def test_keyword_copy(self):
test = self.controller.keywords[0]
copy = test.copy('New Name')
assert_equal(copy.name, 'New Name')
for orig, copied in zip(test.settings, copy.settings):
assert_equal(orig.value, copied.value)
assert_true(copied is not orig)
assert_equal(test.steps, copy.steps)
assert_true(test.steps is not copy.steps)
def test_test_copy_performance(self):
self._run_copy_test(self.controller.tests[0])
def test_keyword_copy_performance(self):
self._run_copy_test(self.controller.keywords[0])
def _run_copy_test(self, item):
self._test_copy(item, 10)
self._test_copy(item, 200)
def _test_copy(self, item, count):
start_time = time.time()
for i in range(0, count):
item.copy(str(i))
self.assertTrue(time.time() < (start_time + 2),
"Copy operation takes too long time")
def _testcasefile(path):
data = TestCaseFile()
data.source = os.path.normpath(path)
return data
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def setUp(self):
self.ctrl = TestCaseFileController(
TestCaseFile(source=self.SOURCE_HTML))
def test_size_change(self):
os.utime(self._filepath, None)
ctrl = TestCaseFileController(TestCaseFile(source=self._filepath).populate())
with open(self._filepath, 'a') as file:
file.write('#Ninja edit\n')
assert_true(ctrl.has_been_modified_on_disk())
def test_xml_library_is_library_keyword(self):
everything_tcf = TestCaseFile(
source=TESTCASEFILE_WITH_EVERYTHING).populate()
assert_true(
self.ns.is_library_keyword(everything_tcf,
'Attributeless Keyword'))
def _assert_contains(self, name):
controller = DataController(TestCaseFile(), None)
for val in self.app.namespace.get_suggestions_for(controller, 'given'):
if val.name == name:
return
raise AssertionError()
def setUp(self):
self.tcf = TestCaseFile()
self._add_var('${foo}', 'foo')
self._add_var('@{bar}', ['b', 'a', 'r'])
self.ctrl = VariableTableController(TestCaseFileController(self.tcf),
self.tcf.variable_table)
def setUp(self):
self.tcf = TestCaseFile()
self.tcf.setting_table.add_metadata('Meta name', 'Some value')
self.ctrl = MetadataListController(TestCaseFileController(self.tcf),
self.tcf.setting_table)
def _get_controller(self, source):
return DataController(TestCaseFile(source=source).populate(), None)
def reload(self):
self.__init__(TestCaseFile(parent=self.data.parent,
source=self.filename).populate(),
project=self._project,
parent=self.parent)
def test_mtime(self):
ctrl = TestCaseFileController(TestCaseFile(source=self._filepath).populate())
assert_false(ctrl.has_been_modified_on_disk())
os.utime(self._filepath, (1,1))
assert_true(ctrl.has_been_modified_on_disk())
def setUp(self):
_TestMacroCommands.setUp(self)
self._ctrl = TestCaseFileController(TestCaseFile())
def _testcasefile(path):
data = TestCaseFile()
data.source = os.path.normpath(path)
return data
