def test_undo_attribute(self):
from gaphor.UML.properties import attribute
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
class A(Element):
attr = attribute("attr", bytes, default="default")
a = element_factory.create(A)
assert a.attr == "default", a.attr
undo_manager.begin_transaction()
a.attr = "five"
undo_manager.commit_transaction()
assert a.attr == "five"
undo_manager.undo_transaction()
assert a.attr == "default", a.attr
undo_manager.redo_transaction()
assert a.attr == "five"
undo_manager.shutdown()
def test_uml_associations(self):
from gaphor.UML.event import AssociationUpdated
from gaphor.UML.properties import association, derivedunion
from gaphor.UML import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
class A(Element):
is_unlinked = False
def unlink(self):
self.is_unlinked = True
Element.unlink(self)
A.a1 = association("a1", A, upper=1)
A.a2 = association("a2", A, upper=1)
A.b1 = association("b1", A, upper="*")
A.b2 = association("b2", A, upper="*")
A.b3 = association("b3", A, upper=1)
A.derived_a = derivedunion(A, "derived_a", 0, 1, A.a1, A.a2)
A.derived_b = derivedunion(A, "derived_b", 0, "*", A.b1, A.b2, A.b3)
events = []
@event_handler(AssociationUpdated)
def handler(event, events=events):
events.append(event)
event_manager.subscribe(handler)
try:
a = element_factory.create(A)
undo_manager.begin_transaction()
a.a1 = element_factory.create(A)
undo_manager.commit_transaction()
assert len(events) == 1, events
assert events[0].property is A.a1
assert undo_manager.can_undo()
undo_manager.undo_transaction()
assert not undo_manager.can_undo()
assert undo_manager.can_redo()
assert len(events) == 2, events
assert events[1].property is A.a1
finally:
event_manager.unsubscribe(handler)
undo_manager.shutdown()
def test_undo_association_1_n(self):
from gaphor.UML.properties import association
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
class A(Element):
pass
class B(Element):
pass
A.one = association("one", B, lower=0, upper=1, opposite="two")
B.two = association("two", A, lower=0, upper="*", opposite="one")
a1 = element_factory.create(A)
a2 = element_factory.create(A)
b1 = element_factory.create(B)
b2 = element_factory.create(B)
undo_manager.begin_transaction()
b1.two = a1
undo_manager.commit_transaction()
assert a1 in b1.two
assert b1 is a1.one
assert len(undo_manager._undo_stack) == 1
assert len(undo_manager._undo_stack[0]._actions
) == 2, undo_manager._undo_stack[0]._actions
undo_manager.undo_transaction()
assert len(b1.two) == 0
assert a1.one is None
assert undo_manager.can_redo()
assert len(undo_manager._redo_stack) == 1
assert len(undo_manager._redo_stack[0]._actions
) == 2, undo_manager._redo_stack[0]._actions
undo_manager.redo_transaction()
assert a1 in b1.two
assert b1 is a1.one
undo_manager.begin_transaction()
b1.two = a2
undo_manager.commit_transaction()
assert a1 in b1.two
assert a2 in b1.two
assert b1 is a1.one
assert b1 is a2.one
undo_manager.shutdown()
def test_element_factory_undo(self):
from gaphor.UML.elementfactory import ElementFactory
from gaphor.UML.element import Element
undo_manager = UndoManager()
undo_manager.init(Application)
undo_manager.begin_transaction()
ef = ElementFactory()
ef.init(Application)
p = ef.create(Element)
assert undo_manager._current_transaction
assert undo_manager._current_transaction._actions
assert undo_manager.can_undo()
undo_manager.commit_transaction()
assert undo_manager.can_undo()
assert ef.size() == 1
undo_manager.undo_transaction()
assert not undo_manager.can_undo()
assert undo_manager.can_redo()
assert ef.size() == 0
undo_manager.redo_transaction()
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert ef.size() == 1
assert ef.lselect()[0] is p
undo_manager.shutdown()
def test_undo_association_1_x(self):
from gaphor.UML.properties import association
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
class A(Element):
pass
class B(Element):
pass
A.one = association("one", B, 0, 1, opposite="two")
B.two = association("two", A, 0, 1)
a = element_factory.create(A)
b = element_factory.create(B)
assert a.one is None
assert b.two is None
undo_manager.begin_transaction()
a.one = b
undo_manager.commit_transaction()
assert a.one is b
assert b.two is a
assert len(undo_manager._undo_stack) == 1
assert len(undo_manager._undo_stack[0]._actions
) == 2, undo_manager._undo_stack[0]._actions
undo_manager.undo_transaction()
assert a.one is None
assert b.two is None
assert undo_manager.can_redo()
assert len(undo_manager._redo_stack) == 1
assert len(undo_manager._redo_stack[0]._actions
) == 2, undo_manager._redo_stack[0]._actions
undo_manager.redo_transaction()
assert len(undo_manager._undo_stack) == 1
assert len(undo_manager._undo_stack[0]._actions
) == 2, undo_manager._undo_stack[0]._actions
assert b.two is a
assert a.one is b
undo_manager.shutdown()
def element_factory():
event_manager = EventManager()
event_manager.subscribe(handler)
clear_events()
factory = ElementFactory(event_manager)
yield factory
clear_events()
def test_element_factory_undo(self):
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
undo_manager.begin_transaction()
p = element_factory.create(Element)
assert undo_manager._current_transaction
assert undo_manager._current_transaction._actions
assert undo_manager.can_undo()
undo_manager.commit_transaction()
assert undo_manager.can_undo()
assert element_factory.size() == 1
undo_manager.undo_transaction()
assert not undo_manager.can_undo()
assert undo_manager.can_redo()
assert element_factory.size() == 0
undo_manager.redo_transaction()
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert element_factory.size() == 1
assert element_factory.lselect()[0] is p
undo_manager.shutdown()
def test_element_factory_rollback(self):
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
undo_manager.begin_transaction()
element_factory.create(Element)
assert undo_manager._current_transaction
assert undo_manager._current_transaction._actions
assert undo_manager.can_undo()
undo_manager.rollback_transaction()
assert not undo_manager.can_undo()
assert element_factory.size() == 0
undo_manager.shutdown()
def element_factory():
ef = ElementFactory()
ef.create(UML.Package).name = "package"
c1 = ef.create(UML.Class)
c1.name = "class"
c2 = ef.create(UML.Class)
c2.name = "class"
i1 = ef.create(UML.Interface)
i1.name = "interface"
c1.ownedAttribute = ef.create(UML.Property)
c1.ownedAttribute[0].name = "attr"
c1.ownedOperation = ef.create(UML.Operation)
c1.ownedOperation[0].name = "oper"
c1.ownedOperation[0].formalParameter = ef.create(UML.Parameter)
UML.model.create_dependency(c1, c2)
UML.model.create_generalization(c1, c2)
UML.model.create_association(c1, c2)
return ef
def factory():
event_manager = EventManager()
return ElementFactory(event_manager)
def element_factory(event_manager):
return ElementFactory(event_manager)
def element_factory():
return ElementFactory(EventManager())
"""
Formatting of UML model elements into text tests.
"""
import unittest
from gaphor.application import Application
from gaphor.UML.elementfactory import ElementFactory
from gaphor.UML.umlfmt import format
import gaphor.UML.uml2 as UML
factory = ElementFactory()
class AttributeTestCase(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
factory.flush()
def test_simple_format(self):
"""Test simple attribute formatting
"""
a = factory.create(UML.Property)
a.name = "myattr"
self.assertEqual("+ myattr", format(a))
a.typeValue = "int"
self.assertEqual("+ myattr: int", format(a))
def test_redo_stack(self):
from gaphor.UML.element import Element
event_manager = EventManager()
undo_manager = UndoManager(event_manager)
element_factory = ElementFactory(event_manager)
undo_manager.begin_transaction()
p = element_factory.create(Element)
assert undo_manager._current_transaction
assert undo_manager._current_transaction._actions
assert undo_manager.can_undo()
undo_manager.commit_transaction()
assert undo_manager.can_undo()
assert element_factory.size() == 1, element_factory.size()
with Transaction(event_manager):
element_factory.create(Element)
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert element_factory.size() == 2
undo_manager.undo_transaction()
assert undo_manager.can_undo()
assert 1 == len(undo_manager._undo_stack)
assert 1 == len(undo_manager._redo_stack)
assert undo_manager.can_redo()
assert element_factory.size() == 1
undo_manager.undo_transaction()
assert not undo_manager.can_undo()
assert undo_manager.can_redo()
assert 0 == len(undo_manager._undo_stack)
assert 2 == len(undo_manager._redo_stack)
# assert element_factory.size() == 0
undo_manager.redo_transaction()
assert 1 == len(undo_manager._undo_stack)
assert 1 == len(undo_manager._redo_stack)
assert undo_manager.can_undo()
assert undo_manager.can_redo()
assert element_factory.size() == 1
undo_manager.redo_transaction()
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert element_factory.size() == 2
assert p in element_factory.lselect()
undo_manager.shutdown()
def element_factory():
event_manager = EventManager()
element_factory = ElementFactory()
yield element_factory
element_factory.shutdown()
event_manager.shutdown()
def test_redo_stack(self):
from gaphor.UML.elementfactory import ElementFactory
from gaphor.UML.element import Element
undo_manager = UndoManager()
undo_manager.init(Application)
undo_manager.begin_transaction()
ef = ElementFactory()
ef.init(Application)
p = ef.create(Element)
assert undo_manager._current_transaction
assert undo_manager._current_transaction._actions
assert undo_manager.can_undo()
undo_manager.commit_transaction()
assert undo_manager.can_undo()
assert ef.size() == 1
with Transaction():
q = ef.create(Element)
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert ef.size() == 2
undo_manager.undo_transaction()
assert undo_manager.can_undo()
self.assertEquals(1, len(undo_manager._undo_stack))
self.assertEquals(1, len(undo_manager._redo_stack))
assert undo_manager.can_redo()
assert ef.size() == 1
undo_manager.undo_transaction()
assert not undo_manager.can_undo()
assert undo_manager.can_redo()
self.assertEquals(0, len(undo_manager._undo_stack))
self.assertEquals(2, len(undo_manager._redo_stack))
assert ef.size() == 0
undo_manager.redo_transaction()
self.assertEquals(1, len(undo_manager._undo_stack))
self.assertEquals(1, len(undo_manager._redo_stack))
assert undo_manager.can_undo()
assert undo_manager.can_redo()
assert ef.size() == 1
undo_manager.redo_transaction()
assert undo_manager.can_undo()
assert not undo_manager.can_redo()
assert ef.size() == 2
assert p in ef.lselect()
undo_manager.shutdown()
