class TestCaseNameValidationTest(unittest.TestCase):
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def test_valid_name(self):
self._validate_name(VALID_NAME, True)
def test_empty_name(self):
self._validate_name('', False)
def test_name_with_only_whitespace(self):
self._validate_name(' ', False)
def test_duplicate_name(self):
self.ctrl.new(VALID_NAME)
self._validate_name(VALID_NAME, False)
self._validate_name(VALID_NAME.upper(), False)
self._validate_name(VALID_NAME.replace(' ', '_'), False)
def test_duplicate_name_when_previous_name_known(self):
ctrl = self.ctrl.new(VALID_NAME)
self._validate_name(VALID_NAME, True, ctrl)
self._validate_name(VALID_NAME.upper(), True, ctrl)
self._validate_name(VALID_NAME.replace(' ', '_'), True, ctrl)
def _validate_name(self, name, expected_valid, named_ctrl=None):
valid = not bool(
self.ctrl.validate_name(name, named_ctrl).error_message)
assert_equals(valid, expected_valid)
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 test_overwrite(self):
ctrl = TestCaseFileController(TestCaseFile(source=self._filepath).populate(),
ChiefController(Namespace()))
os.utime(self._filepath, (1,1))
assert_true(ctrl.has_been_modified_on_disk())
ctrl.save()
assert_false(ctrl.has_been_modified_on_disk())
def test_reload(self):
ctrl = TestCaseFileController(TestCaseFile(source=self._filepath).populate())
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')
class TestCaseNameValidationTest(unittest.TestCase):
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def test_valid_name(self):
self._validate_name(VALID_NAME, True)
def test_empty_name(self):
self._validate_name('', False)
def test_name_with_only_whitespace(self):
self._validate_name(' ', False)
def test_duplicate_name(self):
self.ctrl.new(VALID_NAME)
self._validate_name(VALID_NAME, False)
self._validate_name(VALID_NAME.upper(), False)
self._validate_name(VALID_NAME.replace(' ', '_'), False)
def test_duplicate_name_when_previous_name_known(self):
ctrl = self.ctrl.new(VALID_NAME)
self._validate_name(VALID_NAME, True, ctrl)
self._validate_name(VALID_NAME.upper(), True, ctrl)
self._validate_name(VALID_NAME.replace(' ', '_'), True, ctrl)
def _validate_name(self, name, expected_valid, named_ctrl=None):
valid = not bool(self.ctrl.validate_name(name, named_ctrl).error_message)
assert_equals(valid, expected_valid)
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 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()
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 _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 setUp(self):
class Data(object):
source = directory = None
self.ctrl = TestCaseFileController(Data())
self._has_unsaved_changes = False
self._saved = False
self.messages = [(self._changes, RideDataChangedToDirty),
(self._cleared, RideDataDirtyCleared)]
for listener, topic in self.messages:
PUBLISHER.subscribe(listener, topic)
class TestCaseFileControllerTest(unittest.TestCase):
SOURCE_HTML = os.path.abspath(
os.path.join('tmp', '.path.with.dots', 'test.cases.html'))
SOURCE_TXT = SOURCE_HTML.replace('.html', '.txt')
def setUp(self):
self.ctrl = TestCaseFileController(
TestCaseFile(source=self.SOURCE_HTML))
def test_creation(self):
for st in self.ctrl.settings:
assert_true(st is not None)
assert_equal(len(self.ctrl.settings), 9)
assert_false(self.ctrl.dirty)
def test_has_format(self):
assert_true(self.ctrl.has_format())
@unittest.skip("ERRORS with RF 3.1")
def test_get_format(self):
assert_equal(self.ctrl.get_format(), 'html')
@unittest.skip("ERRORS with RF 3.1")
def test_source(self):
assert_equal(self.ctrl.filename, self.SOURCE_HTML)
def test_longname(self):
assert_equal(self.ctrl.longname, 'Test.Cases')
self.ctrl.parent = lambda: 0
self.ctrl.parent.longname = 'Parent'
assert_equal(self.ctrl.longname, 'Parent.Test.Cases')
@unittest.skip("ERRORS with RF 3.1")
def test_set_format(self):
self.ctrl.set_format('txt')
assert_equal(self.ctrl.filename, self.SOURCE_TXT)
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_new_test(self):
test_ctrl = self.ctrl.create_test('Foo')
assert_equal(test_ctrl.name, 'Foo')
def test_create_keyword(self):
kw_ctrl = self.ctrl.create_keyword('An UK')
assert_equal(kw_ctrl.name, 'An UK')
def test_create_keyword_with_args(self):
kw_ctrl = self.ctrl.create_keyword('UK', '${a1} | ${a2}')
assert_equal(kw_ctrl.name, 'UK')
assert_equal(kw_ctrl.data.args.value, ['${a1}', '${a2}'])
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 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 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_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 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
class TestCaseCreationTest(unittest.TestCase):
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def test_whitespace_is_stripped(self):
test = self.ctrl.new(' ' + VALID_NAME + '\t \n')
assert_equals(test.name, VALID_NAME)
class TestCaseFileControllerTest(unittest.TestCase):
SOURCE_HTML = os.path.abspath(os.path.join("tmp", ".path.with.dots", "test.cases.html"))
SOURCE_TXT = SOURCE_HTML.replace(".html", ".txt")
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile(source=self.SOURCE_HTML))
def test_creation(self):
for st in self.ctrl.settings:
assert_true(st is not None)
assert_equals(len(self.ctrl.settings), 9)
assert_false(self.ctrl.dirty)
def test_has_format(self):
assert_true(self.ctrl.has_format())
def test_get_format(self):
assert_equals(self.ctrl.get_format(), "html")
def test_source(self):
assert_equals(self.ctrl.filename, self.SOURCE_HTML)
def test_longname(self):
assert_equals(self.ctrl.longname, "Test.Cases")
self.ctrl.parent = lambda: 0
self.ctrl.parent.longname = "Parent"
assert_equals(self.ctrl.longname, "Parent.Test.Cases")
def test_set_format(self):
self.ctrl.set_format("txt")
assert_equals(self.ctrl.filename, self.SOURCE_TXT)
def test_add_test_or_kw(self):
assert_equals(len(self.ctrl.tests), 0)
new_test = TestCaseController(self.ctrl, TestCase(TestCaseFile(), "New test"))
self.ctrl.add_test_or_keyword(new_test)
assert_equals(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_new_test(self):
test_ctrl = self.ctrl.create_test("Foo")
assert_equals(test_ctrl.name, "Foo")
def test_create_keyword(self):
kw_ctrl = self.ctrl.create_keyword("An UK")
assert_equals(kw_ctrl.name, "An UK")
def test_create_keyword_with_args(self):
kw_ctrl = self.ctrl.create_keyword("UK", "${a1} | ${a2}")
assert_equals(kw_ctrl.name, "UK")
assert_equals(kw_ctrl.data.args.value, ["${a1}", "${a2}"])
class TestCaseFileControllerTest(unittest.TestCase):
SOURCE_HTML = os.path.abspath(os.path.join('tmp', '.path.with.dots', 'test.cases.html'))
SOURCE_TXT = SOURCE_HTML.replace('.html', '.txt')
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile(source=self.SOURCE_HTML))
def test_creation(self):
for st in self.ctrl.settings:
assert_true(st is not None)
assert_equals(len(self.ctrl.settings), 9)
assert_false(self.ctrl.dirty)
def test_has_format(self):
assert_true(self.ctrl.has_format())
def test_get_format(self):
assert_equals(self.ctrl.get_format(), 'html')
def test_source(self):
assert_equals(self.ctrl.filename, self.SOURCE_HTML)
def test_longname(self):
assert_equals(self.ctrl.longname, 'Test.Cases')
self.ctrl.parent = lambda:0
self.ctrl.parent.longname = 'Parent'
assert_equals(self.ctrl.longname, 'Parent.Test.Cases')
def test_set_format(self):
self.ctrl.set_format('txt')
assert_equals(self.ctrl.filename, self.SOURCE_TXT)
def test_add_test_or_kw(self):
assert_equals(len(self.ctrl.tests), 0)
new_test = TestCaseController(self.ctrl, TestCase(TestCaseFile(), 'New test'))
self.ctrl.add_test_or_keyword(new_test)
assert_equals(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_new_test(self):
test_ctrl = self.ctrl.create_test('Foo')
assert_equals(test_ctrl.name, 'Foo')
def test_create_keyword(self):
kw_ctrl = self.ctrl.create_keyword('An UK')
assert_equals(kw_ctrl.name, 'An UK')
def test_create_keyword_with_args(self):
kw_ctrl = self.ctrl.create_keyword('UK', '${a1} | ${a2}')
assert_equals(kw_ctrl.name, 'UK')
assert_equals(kw_ctrl.data.args.value, ['${a1}', '${a2}'])
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)
class TestCaseCreationTest(unittest.TestCase):
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def test_whitespace_is_stripped(self):
test = self.ctrl.new(' ' + VALID_NAME + '\t \n')
assert_equals(test.name, VALID_NAME)
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_deleting_source_should_remove_it_from_model(self):
chief = create_chief()
chief._controller = TestCaseFileController(
TestCaseFile(source=self._filepath), chief)
os.remove(self._filepath)
ctrl = chief.data
ctrl.remove()
assert_true(chief.data is None)
assert_true(self._removed_datafile is ctrl)
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 setUp(self):
class Data(object):
source = directory = None
self.ctrl = TestCaseFileController(Data())
self._has_unsaved_changes = False
self._saved = False
self.messages = [(self._changes, RideDataChangedToDirty),
(self._cleared, RideDataDirtyCleared)]
for listener, topic in self.messages:
PUBLISHER.subscribe(listener, topic)
def testcase_controller(project=None, data=None):
if data is None:
data = BASE_DATA[:]
base_directory_controller = TestDataDirectoryController(
TestDataDirectory(), project)
directory_controller = TestDataDirectoryController(
TestDataDirectory(), project, base_directory_controller)
tcf_controller = TestCaseFileController(create(data), project,
directory_controller)
tctablectrl = tcf_controller.tests
return tctablectrl[0]
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 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 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 _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 _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 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)
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 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())
class TestMarkUnMarkDirty(unittest.TestCase):
def setUp(self):
class Data(object):
source = directory = None
self.ctrl = TestCaseFileController(Data())
self._has_unsaved_changes = False
self._saved = False
self.messages = [(self._changes, RideDataChangedToDirty),
(self._cleared, RideDataDirtyCleared)]
for listener, topic in self.messages:
PUBLISHER.subscribe(listener, topic)
def tearDown(self):
for listener, topic in self.messages:
PUBLISHER.unsubscribe(listener, topic)
if os.path.exists('path'):
shutil.rmtree('path')
def _changes(self, payload):
self._has_unsaved_changes = payload.datafile
def _cleared(self, payload):
self._saved = payload.datafile
def test_marking_data_dirty_publishes_data_has_changes_message(self):
self.ctrl.mark_dirty()
assert_equals(self._has_unsaved_changes, self.ctrl)
def test_clearing_dirty_mark_publishes_data_saved_message(self):
self.ctrl.mark_dirty()
self.ctrl.unmark_dirty()
assert_equals(self._saved, self.ctrl)
def test_remarking_data_dirty_does_not_publish_data_has_changes_message(self):
self.ctrl.mark_dirty()
self._has_unsaved_changes = None
self.ctrl.mark_dirty()
assert_equals(self._has_unsaved_changes, None)
def test_reclearing_dirty_mark_does_not_publish_data_saved_message(self):
self.ctrl.unmark_dirty()
self._saved = None
self.ctrl.unmark_dirty()
assert_equals(self._saved, None)
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 setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
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)
class TestMarkUnMarkDirty(unittest.TestCase):
def setUp(self):
class Data(object):
source = directory = None
self.ctrl = TestCaseFileController(Data())
self._has_unsaved_changes = False
self._saved = False
self.messages = [(self._changes, RideDataChangedToDirty),
(self._cleared, RideDataDirtyCleared)]
for listener, topic in self.messages:
PUBLISHER.subscribe(listener, topic)
def tearDown(self):
for listener, topic in self.messages:
PUBLISHER.unsubscribe(listener, topic)
if os.path.exists('path'):
shutil.rmtree('path')
def _changes(self, payload):
self._has_unsaved_changes = payload.datafile
def _cleared(self, payload):
self._saved = payload.datafile
def test_marking_data_dirty_publishes_data_has_changes_message(self):
self.ctrl.mark_dirty()
assert_equals(self._has_unsaved_changes, self.ctrl)
def test_clearing_dirty_mark_publishes_data_saved_message(self):
self.ctrl.mark_dirty()
self.ctrl.unmark_dirty()
assert_equals(self._saved, self.ctrl)
def test_remarking_data_dirty_does_not_publish_data_has_changes_message(
self):
self.ctrl.mark_dirty()
self._has_unsaved_changes = None
self.ctrl.mark_dirty()
assert_equals(self._has_unsaved_changes, None)
def test_reclearing_dirty_mark_does_not_publish_data_saved_message(self):
self.ctrl.unmark_dirty()
self._saved = None
self.ctrl.unmark_dirty()
assert_equals(self._saved, None)
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())
open(self._filepath, 'a').write('#Ninja edit\n')
assert_true(ctrl.has_been_modified_on_disk())
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):
self.tcf = TestCaseFile()
filectrl = TestCaseFileController(self.tcf)
filectrl.resource_import_modified = Mock()
self.ctrl = ImportSettingsController(filectrl, self.tcf.setting_table)
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile()).tests
def file_controller():
return TestCaseFileController(TestCaseFile())
def setUp(self):
self.ctrl = TestCaseFileController(TestCaseFile(source=self.SOURCE_HTML))
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 setUp(self):
_TestMacroCommands.setUp(self)
self._ctrl = TestCaseFileController(TestCaseFile())
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())
