def test_run_demo(self):
demo = runpy.run_path(DEMO_PATH)["demo"]
tester = UITester()
with tester.create_ui(demo) as ui:
simple_int_field = tester.find_by_id(ui, "simple_int")
custom_int_field = tester.find_by_id(ui, "custom_int")
text_int_field = tester.find_by_id(ui, "text_int")
readonly_int_field = tester.find_by_id(ui, "readonly_int")
# Modify the value to something invalid
simple_int_field.perform(KeyClick("Backspace"))
simple_int_field.perform(KeySequence("a")) # not a number!
# Check the value has not changed
self.assertEqual(demo.int_trait, 1)
self.assertEqual(custom_int_field.inspect(DisplayedText()), "1")
self.assertEqual(text_int_field.inspect(DisplayedText()), "1")
self.assertEqual(readonly_int_field.inspect(DisplayedText()), "1")
# Modify the value on the GUI to a good value
simple_int_field.perform(KeyClick("Backspace"))
simple_int_field.perform(KeySequence("2"))
# Check
self.assertEqual(demo.int_trait, 2)
self.assertEqual(custom_int_field.inspect(DisplayedText()), "2")
self.assertEqual(text_int_field.inspect(DisplayedText()), "2")
self.assertEqual(readonly_int_field.inspect(DisplayedText()), "2")
def test_enum_editor_demo(self):
demo = runpy.run_path(DEMO_PATH)["demo"]
tester = UITester()
with tester.create_ui(demo) as ui:
simple_enum = tester.find_by_id(ui, "simple")
simple_text_enum = tester.find_by_id(ui, "simple_text")
radio_enum = tester.find_by_id(ui, "radio")
list_enum = tester.find_by_id(ui, "list")
text = tester.find_by_id(ui, "text")
readonly = tester.find_by_id(ui, "readonly")
self.assertEqual(demo.name_list, 'A-495')
simple_enum.locate(Index(1)).perform(MouseClick())
self.assertEqual(demo.name_list, 'A-498')
for _ in range(5):
simple_text_enum.perform(KeyClick("Backspace"))
simple_text_enum.perform(KeySequence("R-1226"))
simple_text_enum.perform(KeyClick("Enter"))
self.assertEqual(demo.name_list, 'R-1226')
radio_enum.locate(Index(5)).perform(MouseClick())
self.assertEqual(demo.name_list, 'Foo')
list_enum.locate(Index(3)).perform(MouseClick())
self.assertEqual(demo.name_list, 'TS-17')
for _ in range(5):
text.perform(KeyClick("Backspace"))
text.perform(KeySequence("A-498"))
text.perform(KeyClick("Enter"))
self.assertEqual(demo.name_list, 'A-498')
demo.name_list = 'Foo'
displayed_simple = simple_enum.inspect(DisplayedText())
disp_simple_text = simple_text_enum.inspect(DisplayedText())
selected_radio = radio_enum.inspect(SelectedText())
selected_list = list_enum.inspect(SelectedText())
displayed_text = text.inspect(DisplayedText())
displayed_readonly = readonly.inspect(DisplayedText())
displayed_selected = [
displayed_simple,
disp_simple_text,
selected_radio,
selected_list,
displayed_text,
displayed_readonly,
]
for text in displayed_selected:
self.assertEqual(text, 'Foo')
def test_edit_on_first_click_false(self):
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
tester = UITester()
with tester.create_ui(object_list,
dict(view=edit_on_first_click_false_view)) as ui:
wrapper = tester.find_by_name(ui, "values").locate(Cell(5, 0))
# single click will not activate edit mode
wrapper.perform(MouseClick())
with self.assertRaises(Disabled):
wrapper.perform(KeySequence("abc"))
# double click will activate edit mode
wrapper.perform(MouseDClick())
wrapper.perform(KeySequence("abc"))
self.assertEqual(object_list.values[5].value, "abc")
def test_propagate_errors_switch_selection(self):
obj = ObjectWithValidatedList()
ui_tester = UITester()
with ui_tester.create_ui(obj, {'view': selection_view}) as ui:
something_ui = ui_tester.find_by_name(ui, "inst")
something_ui.locate(Index(0)).perform(MouseClick())
some_string_field = something_ui.locate(
TargetByName('some_string'))
some_string_field.perform(KeySequence("bcde"))
some_string_field.perform(KeyClick("Enter"))
ok_button = ui_tester.find_by_id(ui, "OK")
instance_editor_ui = something_ui._target._ui
instance_editor_ui_parent = something_ui._target._ui.parent
self.assertNotEqual(instance_editor_ui, ui)
self.assertEqual(instance_editor_ui_parent, ui)
self.assertEqual(instance_editor_ui.errors, ui.errors)
self.assertFalse(ok_button.inspect(IsEnabled()))
# change to a different selected that is not in an error state
something_ui.locate(Index(1)).perform(MouseClick())
self.assertTrue(ok_button.inspect(IsEnabled()))
def test_boolean_editor_simple_demo(self):
demo = runpy.run_path(DEMO_PATH)["demo"]
tester = UITester()
with tester.create_ui(demo) as ui:
simple = tester.find_by_id(ui, 'simple')
readonly = tester.find_by_id(ui, 'readonly')
text = tester.find_by_id(ui, 'text')
count_changes = tester.find_by_name(ui, "count_changes")
simple.perform(MouseClick())
self.assertEqual(demo.my_boolean_trait, True)
for _ in range(4):
text.perform(KeyClick("Backspace"))
text.perform(KeySequence("False"))
text.perform(KeyClick("Enter"))
self.assertEqual(demo.my_boolean_trait, False)
displayed_count_changes = count_changes.inspect(DisplayedText())
self.assertEqual(displayed_count_changes, '2')
self.assertEqual(displayed_count_changes, str(demo.count_changes))
demo.my_boolean_trait = True
displayed = readonly.inspect(DisplayedText())
self.assertEqual(displayed, "True")
simple_is_checked = simple.inspect(IsChecked())
self.assertEqual(simple_is_checked, True)
def test_propagate_errors(self):
obj = ObjectWithValidatedInstance()
ui_tester = UITester()
with ui_tester.create_ui(obj) as ui:
something_ui = ui_tester.find_by_name(ui, "something")
some_string_field = something_ui.locate(
TargetByName('some_string')
)
some_string_field.perform(KeySequence("abcd"))
some_string_field.perform(KeyClick("Enter"))
ok_button = ui_tester.find_by_id(ui, "OK")
instance_editor_ui = something_ui._target._ui
instance_editor_ui_parent = something_ui._target._ui.parent
self.assertNotEqual(
instance_editor_ui, ui
)
self.assertEqual(
instance_editor_ui_parent, ui
)
self.assertEqual(
instance_editor_ui.errors, ui.errors
)
self.assertFalse(ok_button.inspect(IsEnabled()))
def test_custom_editor_with_selection(self):
obj = ObjectWithList()
tester = UITester()
with tester.create_ui(obj, {'view': selection_view}) as ui:
# test that the current object is None
self.assertIsNone(obj.inst)
# test that the displayed text is correct
instance = tester.find_by_name(ui, "inst")
text = instance.inspect(SelectedText())
self.assertEqual(text, obj.inst_list[0].name)
# test that changing selection works
instance = tester.find_by_name(ui, "inst")
instance.locate(Index(1)).perform(MouseClick())
self.assertIs(obj.inst, obj.inst_list[1])
# test that the displayed text is correct
text = instance.inspect(SelectedText())
self.assertEqual(text, obj.inst_list[1].name)
# test editing the view works
value_txt = instance.find_by_name("value")
value_txt.perform(KeySequence("abc"))
self.assertEqual(obj.inst.value, "twoabc")
def test_custom_editor(self):
obj = ObjectWithInstance()
tester = UITester()
with tester.create_ui(obj, dict(view=get_view("custom"))) as ui:
value_txt = tester.find_by_name(ui, "inst").find_by_name("value")
value_txt.perform(KeySequence("abc"))
self.assertEqual(obj.inst.value, "abc")
def test_simple_editor_auto_set_text(self):
# Test with auto_set set to True.
view = View(Item("dir_path", editor=DirectoryEditor(auto_set=True)))
obj = DirectoryModel()
tester = UITester()
with tester.create_ui(obj, dict(view=view)) as ui:
dirpath_field = tester.find_by_name(ui, "dir_path")
dirpath_field.perform(KeySequence("some_dir"))
self.assertEqual(obj.dir_path, "some_dir")
def test_simple_editor_auto_set_text(self):
# Test with auto_set set to True.
view = View(Item("filepath", editor=FileEditor(auto_set=True)))
obj = FileModel()
tester = UITester()
with tester.create_ui(obj, dict(view=view)) as ui:
filepath_field = tester.find_by_name(ui, "filepath")
filepath_field.perform(KeySequence("some_file.txt"))
self.assertEqual(obj.filepath, "some_file.txt")
def test_simple_editor(self):
obj = ObjectWithInstance()
tester = UITester()
with tester.create_ui(obj, dict(view=get_view("simple"))) as ui:
instance = tester.find_by_name(ui, "inst")
instance.perform(MouseClick())
value_txt = instance.find_by_name("value")
value_txt.perform(KeySequence("abc"))
self.assertEqual(obj.inst.value, "abc")
def test_table_editor_escape_retain_edit(self):
object_list = ObjectListWithSelection(values=[ListItem(other_value=0)])
tester = UITester()
with tester.create_ui(object_list, dict(view=select_row_view)) as ui:
cell = tester.find_by_name(ui, "values").locate(Cell(0, 1))
cell.perform(MouseClick())
cell.perform(KeySequence("123"))
cell.perform(KeyClick("Esc")) # exit edit mode, did not revert
self.assertEqual(object_list.values[0].other_value, 123)
def test_table_editor_modify_cell_with_tester(self):
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
tester = UITester()
with tester.create_ui(object_list, dict(view=select_row_view)) as ui:
wrapper = tester.find_by_name(ui, "values").locate(Cell(5, 0))
wrapper.perform(MouseClick()) # activate edit mode
wrapper.perform(KeySequence("abc"))
self.assertEqual(object_list.selected.value, "abc")
# second column refers to an Int type
original = object_list.selected.other_value
wrapper = tester.find_by_name(ui, "values").locate(Cell(5, 1))
wrapper.perform(MouseClick())
wrapper.perform(KeySequence("abc")) # invalid
self.assertEqual(object_list.selected.other_value, original)
for _ in range(3):
wrapper.perform(KeyClick("Backspace"))
wrapper.perform(KeySequence("12")) # now ok
self.assertEqual(object_list.selected.other_value, 12)
def test_simple_auto_set_update_text(self):
foo = Foo()
view = get_view(style="simple", auto_set=True)
tester = UITester()
with tester.create_ui(foo, dict(view=view)) as ui:
with self.assertTraitChanges(foo, "name", count=3):
name_field = tester.find_by_name(ui, "name")
name_field.perform(KeySequence("NEW"))
# with auto-set the displayed name should match the name trait
display_name = name_field.inspect(DisplayedText())
self.assertEqual(foo.name, "NEW")
self.assertEqual(display_name, foo.name)
def test_modify_person_name(self):
phonebook = Phonebook(people=get_people(), )
tester = UITester()
with tester.create_ui(phonebook, dict(view=notebook_view)) as ui:
list_ = tester.find_by_name(ui, "people")
list_.locate(Index(1)).perform(MouseClick())
name_field = list_.locate(Index(1)).find_by_name("name")
for _ in range(4):
name_field.perform(KeyClick("Backspace"))
name_field.perform(KeySequence("Pete"))
self.assertEqual(phonebook.people[1].name, "Pete")
def test_custom_auto_set_false_update_text(self):
# the auto_set flag is disregard for custom editor. (not true on WX)
foo = Foo()
view = get_view(auto_set=False, style="custom")
tester = UITester()
with tester.create_ui(foo, dict(view=view)) as ui:
name_field = tester.find_by_name(ui, "name")
name_field.perform(KeySequence("NEW"))
name_field.perform(KeyClick("Enter"))
display_name = name_field.inspect(DisplayedText())
self.assertEqual(foo.name, "NEW\n")
self.assertEqual(display_name, foo.name)
def test_custom_auto_set_true_update_text(self):
# the auto_set flag is disregard for custom editor. (not true on WX)
foo = Foo()
view = get_view(auto_set=True, style="custom")
tester = UITester()
with tester.create_ui(foo, dict(view=view)) as ui:
with self.assertTraitChanges(foo, "name", count=3):
name_field = tester.find_by_name(ui, "name")
name_field.perform(KeySequence("NEW"))
# with auto-set the displayed name should match the name trait
display_name = name_field.inspect(DisplayedText())
self.assertEqual(foo.name, "NEW")
self.assertEqual(display_name, foo.name)
def test_readonly_editor(self):
foo = Foo(name="A name")
view = get_view(style="readonly", auto_set=True)
tester = UITester()
with tester.create_ui(foo, dict(view=view)) as ui:
name_field = tester.find_by_name(ui, "name")
with self.assertRaises(InteractionNotSupported):
name_field.perform(KeySequence("NEW"))
# Trying to type should do nothing
with self.assertRaises(InteractionNotSupported):
name_field.perform(KeyClick("Space"))
display_name = name_field.inspect(DisplayedText())
self.assertEqual(display_name, "A name")
def test_simple_editor_set_text_to_nonexisting_path(self):
# Test setting the editor to a nonexisting dirpath
# e.g. use case for creating a new file.
view = View(Item("dir_path", editor=DirectoryEditor()))
obj = DirectoryModel()
tester = UITester()
with tester.create_ui(obj, dict(view=view)) as ui:
dirpath_field = tester.find_by_name(ui, "dir_path")
dirpath_field.perform(KeySequence("some_dir"))
dirpath_field.perform(KeyClick("Enter"))
self.assertEqual(obj.dir_path, "some_dir")
def test_change_text_boolean_changes_trait(self):
view = View(Item("true_or_false", style='text'))
obj = BoolModel()
tester = UITester()
with tester.create_ui(obj, dict(view=view)) as ui:
self.assertEqual(obj.true_or_false, False)
text_field = tester.find_by_name(ui, 'true_or_false')
for _ in range(5):
text_field.perform(KeyClick("Backspace"))
text_field.perform(KeySequence("True"))
text_field.perform(KeyClick("Enter"))
self.assertEqual(obj.true_or_false, True)
def test_list_editor_demo(self):
demo = runpy.run_path(DEMO_PATH)["demo"]
tester = UITester()
with tester.create_ui(demo) as ui:
custom_list = tester.find_by_id(ui, "custom")
item1 = custom_list.locate(Index(1))
for _ in range(6):
item1.perform(KeyClick("Backspace"))
item1.perform(KeySequence("Othello"))
item1.perform(KeyClick("Enter"))
self.assertEqual(demo.play_list,
["The Merchant of Venice", "Othello", "MacBeth"])
def test_instance_editor_demo(self):
demo = runpy.run_path(DEMO_PATH)["demo"]
tester = UITester()
with tester.create_ui(demo) as ui:
simple = tester.find_by_id(ui, "simple")
custom = tester.find_by_id(ui, "custom")
occupation = custom.find_by_name("occupation")
occupation.perform(KeySequence("Job"))
occupation.perform(KeyClick("Enter"))
self.assertEqual(demo.sample_instance.occupation, "Job")
simple.perform(MouseClick())
name = simple.find_by_name("name")
name.perform(KeySequence("ABC"))
name.perform(KeyClick("Enter"))
self.assertEqual(demo.sample_instance.name, "ABC")
demo.sample_instance.name = "XYZ"
simple_displayed = name.inspect(DisplayedText())
custom_name = custom.find_by_name("name")
custom_displayed = custom_name.inspect(DisplayedText())
self.assertEqual(simple_displayed, "XYZ")
self.assertEqual(custom_displayed, "XYZ")
def check_enum_object_update(self, view):
enum_edit = EnumModel()
tester = UITester()
with tester.create_ui(enum_edit, dict(view=view)) as ui:
self.assertEqual(enum_edit.value, "one")
combobox = tester.find_by_name(ui, "value")
for _ in range(3):
combobox.perform(KeyClick("Backspace"))
combobox.perform(KeySequence("two"))
combobox.perform(KeyClick("Enter"))
self.assertEqual(enum_edit.value, "two")
def test_range_text_editor_set_with_text_after_empty(self):
model = RangeModel()
view = View(
Item("value", editor=RangeEditor(low=1, high=12, mode="text")))
tester = UITester()
with tester.create_ui(model, dict(view=view)) as ui:
number_field_text = tester.find_by_name(ui, "value")
# Delete all contents of textbox
for _ in range(5):
number_field_text.perform(KeyClick("Backspace"))
number_field_text.perform(KeySequence("11"))
number_field_text.perform(KeyClick("Enter"))
displayed = number_field_text.inspect(DisplayedText())
self.assertEqual(model.value, 11)
self.assertEqual(displayed, str(model.value))
def test_simple_editor_disabled(self):
enum_edit = EnumModel(value="two")
view = View(
UItem(
"value",
style="simple",
enabled_when="value == 'one'",
editor=EnumEditor(evaluate=True, values=["one", "two"]),
), )
tester = UITester()
with tester.create_ui(enum_edit, dict(view=view)) as ui:
combobox = tester.find_by_name(ui, "value")
with self.assertRaises(Disabled):
combobox.perform(KeyClick("Enter"))
with self.assertRaises(Disabled):
combobox.perform(KeySequence("two"))
def test_set_text_out_of_range(self):
model = RangeModel()
view = View(
Item('float_value',
editor=RangeEditor(mode='text', low=0.0, high=1)), )
tester = UITester()
with tester.create_ui(model, dict(view=view)) as ui:
float_value_field = tester.find_by_name(ui, "float_value")
for _ in range(3):
float_value_field.perform(KeyClick("Backspace"))
# set a value out of the range [0.0, 1]
float_value_field.perform(KeySequence("2.0"))
float_value_field.perform(KeyClick("Enter"))
self.assertTrue(0.0 <= model.float_value <= 1)
def test_locate_element_and_edit(self):
obj = ListTraitTest(people=get_people(), style="simple")
tester = UITester()
with tester.create_ui(obj) as ui:
# sanity check
self.assertEqual(obj.people[7].name, "Fields")
people_list = tester.find_by_name(ui, "people")
item = people_list.locate(Index(7))
item.perform(MouseClick())
name_field = item.find_by_name("name")
for _ in range(6):
name_field.perform(KeyClick("Backspace"))
name_field.perform(KeySequence("David"))
displayed = name_field.inspect(DisplayedText())
self.assertEqual(obj.people[7].name, "David")
self.assertEqual(displayed, obj.people[7].name)
def test_simple_evaluate_editor_object_no_auto_set(self):
view = get_evaluate_view("simple", auto_set=False)
enum_edit = EnumModel()
tester = UITester()
with tester.create_ui(enum_edit, dict(view=view)) as ui:
self.assertEqual(enum_edit.value, "one")
combobox = tester.find_by_name(ui, "value")
for _ in range(3):
combobox.perform(KeyClick("Backspace"))
combobox.perform(KeySequence("two"))
self.assertEqual(enum_edit.value, "one")
combobox.perform(KeyClick("Enter"))
self.assertEqual(enum_edit.value, "two")
def test_simple_auto_set_false_do_not_update_qt(self):
foo = Foo(name="")
view = get_view(style="simple", auto_set=False)
tester = UITester()
with tester.create_ui(foo, dict(view=view)) as ui:
name_field = tester.find_by_name(ui, "name")
name_field.perform(KeySequence("NEW"))
# with auto-set as False the displayed name should match what has
# been typed not the trait itself, After "Enter" is pressed it
# should match the name trait
display_name = name_field.inspect(DisplayedText())
self.assertEqual(foo.name, "")
self.assertEqual(display_name, "NEW")
name_field.perform(KeyClick("Enter"))
display_name = name_field.inspect(DisplayedText())
self.assertEqual(foo.name, "NEW")
self.assertEqual(display_name, foo.name)
def when_opened(tester):
with tester.capture_error():
try:
dialog_ui = tester.get_dialog_widget()._ui
# If auto_process_events was not set to false, this
# will block due to deadlocks with ModalDialogTester.
ui_tester = UITester(auto_process_events=False)
value = ui_tester.find_by_name(dialog_ui, "value")
value.perform(KeySequence("Hello"))
self.assertEqual(obj.inst.value, "")
ok_button = ui_tester.find_by_id(dialog_ui, "OK")
ok_button.perform(MouseClick())
finally:
# If the block above fails, the dialog will block
# forever. Close it regardless.
if tester.get_dialog_widget() is not None:
tester.close(accept=True)
