class TestUndoManager(unittest.TestCase, UnittestTools):
def setUp(self):
self.stack_a = CommandStack()
self.stack_b = CommandStack()
self.undo_manager = UndoManager()
self.stack_a.undo_manager = self.undo_manager
self.stack_b.undo_manager = self.undo_manager
self.undo_manager.active_stack = self.stack_a
self.command = SimpleCommand()
# Command pushing tests ---------------------------------------------------
def test_undo(self):
self.assertEqual(self.stack_a._index, -1)
self.stack_a.push(self.command)
self.assertEqual(self.stack_a._index, 0)
with self.assertTraitChanges(self.undo_manager,
'stack_updated',
count=1):
self.undo_manager.undo()
self.assertEqual(self.stack_a._index, -1)
def test_redo(self):
self.assertEqual(self.stack_a._index, -1)
self.stack_a.push(self.command)
self.undo_manager.undo()
self.assertEqual(self.stack_a._index, -1)
with self.assertTraitChanges(self.undo_manager,
'stack_updated',
count=1):
self.undo_manager.redo()
self.assertEqual(self.stack_a._index, 0)
def test_change_active_stack(self):
for _ in range(5):
self.stack_a.push(self.command)
self.assertEqual(self.stack_a._index, 4)
self.undo_manager.active_stack = self.stack_b
for _ in range(5):
self.stack_b.push(self.command)
self.assertEqual(self.stack_b._index, 4)
for _ in range(3):
self.undo_manager.undo()
self.undo_manager.redo()
self.assertEqual(self.stack_a._index, 4)
self.assertEqual(self.stack_b._index, 2)
def test_active_stack_clean(self):
self.assertTrue(self.undo_manager.active_stack_clean)
self.stack_a.push(self.command)
self.assertFalse(self.undo_manager.active_stack_clean)
self.undo_manager.active_stack = None
self.assertTrue(self.undo_manager.active_stack_clean)
class TestUndoAction(unittest.TestCase):
def setUp(self):
self.stack = CommandStack()
self.undo_manager = UndoManager()
self.stack.undo_manager = self.undo_manager
self.undo_manager.active_stack = self.stack
self.command = SimpleCommand()
def test_update(self):
undo_action = UndoAction(command=self.command,
undo_manager=self.undo_manager)
self.stack.push(self.command)
self.assertTrue(undo_action.enabled)
self.assertEqual(undo_action.name, "&Undo Increment by 1")
class TestCommandStack(unittest.TestCase):
def setUp(self):
self.stack = CommandStack()
undo_manager = UndoManager()
self.stack.undo_manager = undo_manager
self.command = SimpleCommand()
# Command pushing tests ---------------------------------------------------
def test_empty_command_stack(self):
with self.assert_n_commands_pushed(self.stack, 0):
pass
def test_1_command_pushed(self):
with self.assert_n_commands_pushed(self.stack, 1):
self.stack.push(self.command)
def test_n_command_pushed(self):
n = 4
with self.assert_n_commands_pushed(self.stack, n):
for i in range(n):
self.stack.push(self.command)
# Undo/Redo tests ---------------------------------------------------------
def test_undo_1_command(self):
with self.assert_n_commands_pushed_and_undone(self.stack, 1):
self.stack.push(self.command)
self.assertEqual(self.stack.undo_name, self.command.name)
self.stack.undo()
def test_undo_n_command(self):
n = 4
with self.assert_n_commands_pushed_and_undone(self.stack, n):
for i in range(n):
self.stack.push(self.command)
for i in range(n):
self.stack.undo()
def test_undo_redo_sequence_nr(self):
n = 4
for i in range(n):
self.stack.push(self.command)
self.assertEqual(self.stack._index, 3)
# undo back to the 1st command in the stack
self.stack.undo(1)
self.assertEqual(self.stack._index, 0)
# redo back to the 3rd command in the stack
self.stack.redo(3)
self.assertEqual(self.stack._index, 2)
def test_undo_unnamed_command(self):
unnamed_command = UnnamedCommand()
with self.assert_n_commands_pushed(self.stack, 1):
self.stack.push(unnamed_command)
# But the command cannot be undone because it has no name
self.assertEqual(self.stack.undo_name, "")
# This is a no-op
self.stack.undo()
def test_undo_redo_1_command(self):
with self.assert_n_commands_pushed(self.stack, 1):
self.stack.push(self.command)
self.stack.undo()
self.stack.redo()
# Macro tests -------------------------------------------------------------
def test_define_macro(self):
with self.assert_n_commands_pushed(self.stack, 1):
add_macro(self.stack, num_commands=2)
def test_undo_macro(self):
with self.assert_n_commands_pushed_and_undone(self.stack, 1):
# The 2 pushes are viewed as 1 command
add_macro(self.stack, num_commands=2)
self.stack.undo()
# Cleanliness tests -------------------------------------------------------
def test_empty_stack_is_clean(self):
self.assertTrue(self.stack.clean)
def test_non_empty_stack_is_dirty(self):
self.stack.push(self.command)
self.assertFalse(self.stack.clean)
def test_make_clean(self):
# This makes it dirty by default
self.stack.push(self.command)
# Make the current tip of the stack clean
self.stack.clean = True
self.assertTrue(self.stack.clean)
def test_make_dirty(self):
# Start from a clean state:
self.stack.push(self.command)
self.stack.clean = True
self.stack.clean = False
self.assertFalse(self.stack.clean)
def test_save_push_undo_is_clean(self):
self.stack.push(self.command)
self.stack.clean = True
self.stack.push(self.command)
self.stack.undo()
self.assertTrue(self.stack.clean)
def test_save_push_save_undo_is_clean(self):
self.stack.push(self.command)
self.stack.clean = True
self.stack.push(self.command)
self.stack.clean = True
self.stack.undo()
self.assertTrue(self.stack.clean)
def test_push_undo_save_redo_is_dirty(self):
self.stack.push(self.command)
self.stack.undo()
self.stack.clean = True
self.stack.redo()
self.assertFalse(self.stack.clean)
def test_clear(self):
n = 5
for _ in range(n):
self.stack.push(self.command)
self.stack.clear()
self.assertEqual(self.stack._stack, [])
self.assertTrue(self.stack.clean)
# Assertion helpers -------------------------------------------------------
@contextmanager
def assert_n_commands_pushed(self, stack, n):
current_length = len(stack._stack)
yield
# N commands have been pushed...
self.assertEqual(len(stack._stack), current_length + n)
# ... and the state is at the tip of the stack...
self.assertEqual(stack._index, current_length + n - 1)
@contextmanager
def assert_n_commands_pushed_and_undone(self, stack, n):
current_length = len(stack._stack)
yield
# N commands have been pushed and then reverted. The stack still
# contains the commands...
self.assertEqual(len(stack._stack), n)
# ... but we are back to the initial (clean) state
self.assertEqual(stack._index, current_length - 1)