def test_commentline_same_comment_glue(create):
"""Test comment line item gluing to already connected comment item."""
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
connect(line, line.head, comment)
glued = allow(line, line.tail, comment)
assert not glued
def test_class_association_undo_redo(event_manager, element_factory,
undo_manager):
with Transaction(event_manager):
diagram = element_factory.create(Diagram)
assert 0 == len(diagram.connections.solver.constraints)
with Transaction(event_manager):
ci1 = diagram.create(ClassItem,
subject=element_factory.create(UML.Class))
assert 6 == len(diagram.connections.solver.constraints)
with Transaction(event_manager):
ci2 = diagram.create(ClassItem,
subject=element_factory.create(UML.Class))
assert 12 == len(diagram.connections.solver.constraints)
with Transaction(event_manager):
a = diagram.create(AssociationItem)
connect(a, a.head, ci1)
connect(a, a.tail, ci2)
# Diagram, Association, 2x Class, Property, LiteralSpecification
assert 6 == len(element_factory.lselect())
assert 14 == len(diagram.connections.solver.constraints)
undo_manager.clear_undo_stack()
assert not undo_manager.can_undo()
with Transaction(event_manager):
ci2.unlink()
assert undo_manager.can_undo()
def get_connected(handle):
"""Get item connected to line via handle."""
cinfo = diagram.connections.get_connection(handle)
if cinfo:
return cinfo.connected
return None
assert ci1 == get_connected(a.head)
assert None is get_connected(a.tail)
for i in range(3):
assert 7 == len(diagram.connections.solver.constraints)
undo_manager.undo_transaction()
assert 14 == len(diagram.connections.solver.constraints)
assert ci1 == get_connected(a.head)
assert ci2.id == get_connected(a.tail).id
undo_manager.redo_transaction()
def test_commentline_annotated_element(create, diagram):
"""Test comment line item annotated element creation
"""
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
connect(line, line.head, comment)
# connected, but no annotated element yet
assert diagram.canvas.get_connection(line.head)
assert not comment.subject.annotatedElement
def two_classes_and_a_generalization(diagram, element_factory):
gen_cls = element_factory.create(UML.Class)
spc_cls = element_factory.create(UML.Class)
gen_cls_item = diagram.create(ClassItem, subject=gen_cls)
spc_cls_item = diagram.create(ClassItem, subject=spc_cls)
gen_item = diagram.create(GeneralizationItem)
connect(gen_item, gen_item.handles()[0], gen_cls_item)
connect(gen_item, gen_item.handles()[1], spc_cls_item)
return gen_cls_item, spc_cls_item, gen_item
def create_lifeline_with_execution_specification(diagram, element_factory):
lifeline = diagram.create(LifelineItem,
subject=element_factory.create(UML.Lifeline))
lifeline.lifetime.visible = True
exec_spec = diagram.create(ExecutionSpecificationItem)
connect(exec_spec,
exec_spec.handles()[0], lifeline, lifeline.lifetime.port)
return lifeline, exec_spec
def test_commentline_item_with_no_subject_connect(create, diagram):
"""Test comment line connecting to comment and actor items."""
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
gi = create(GeneralizationItem)
connect(line, line.head, comment)
connect(line, line.tail, gi)
assert diagram.canvas.get_connection(line.tail).connected is gi
assert len(comment.subject.annotatedElement) == 0
def test_glue_to_class(connected_association):
asc, c1, c2 = connected_association
glued = allow(asc, asc.head, c1)
assert glued
connect(asc, asc.head, c1)
glued = allow(asc, asc.tail, c2)
assert glued
def test_commentline_element_connect(create, diagram):
"""Test comment line connecting to comment and actor items."""
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
ac = create(ActorItem, UML.Actor)
connect(line, line.head, comment)
connect(line, line.tail, ac)
assert diagram.canvas.get_connection(line.tail).connected is ac
assert len(comment.subject.annotatedElement) == 1
assert ac.subject in comment.subject.annotatedElement
def test_connection(element_factory, diagram):
"""Test extension item connection."""
ext = diagram.create(ExtensionItem)
st = diagram.create(ClassItem,
subject=element_factory.create(UML.Stereotype))
cls = diagram.create(ClassItem, subject=element_factory.create(UML.Class))
connect(ext, ext.tail, st)
connect(ext, ext.head, cls)
def test_connection(element_factory, diagram):
"""Test package import item connection."""
pkg_import = diagram.create(PackageImportItem)
package1 = diagram.create(PackageItem,
subject=element_factory.create(UML.Package))
package2 = diagram.create(PackageItem,
subject=element_factory.create(UML.Package))
connect(pkg_import, pkg_import.tail, package1)
connect(pkg_import, pkg_import.head, package2)
def test_connect_connector_on_both_ends_to_proxy_port(
connector_item: ConnectorItem,
head_proxy_port_item: ProxyPortItem,
tail_proxy_port_item: ProxyPortItem,
):
connect(connector_item, connector_item.handles()[0], head_proxy_port_item)
connect(connector_item, connector_item.handles()[1], tail_proxy_port_item)
assert connector_item.subject
assert head_proxy_port_item.subject in connector_item.subject.end[:].role
assert tail_proxy_port_item.subject in connector_item.subject.end[:].role
def test_unioncache_in_derived_union(diagram, element_factory):
uc1 = diagram.create(diagramitems.UseCaseItem,
subject=element_factory.create(UML.UseCase))
uc2 = diagram.create(diagramitems.UseCaseItem,
subject=element_factory.create(UML.UseCase))
include = diagram.create(diagramitems.IncludeItem)
connect(include, include.handles()[0], uc1)
connect(include, include.handles()[1], uc2)
assert uc1.subject in include.subject.target
assert include.subject.ownedElement == []
def connected_association(create):
asc = create(AssociationItem)
c1 = create(ClassItem, UML.Class)
c2 = create(ClassItem, UML.Class)
connect(asc, asc.head, c1)
assert asc.subject is None # no UML metaclass yet
connect(asc, asc.tail, c2)
assert asc.subject is not None
return asc, c1, c2
def test_allow_both_ends_connected_to_the_same_class(create, clone):
asc = create(AssociationItem)
c1 = create(ClassItem, UML.Class)
connect(asc, asc.head, c1)
connect(asc, asc.tail, c1)
new = clone(asc)
c2 = create(ClassItem, UML.Class)
assert allow(new, new.head, c1)
assert allow(new, new.tail, c1)
assert not allow(new, new.head, c2)
assert not allow(new, new.tail, c2)
def test_connection_namespace(element_factory, diagram):
"""Test extension item connection."""
pkg = element_factory.create(UML.Package)
diagram.package = pkg
ext = diagram.create(ExtensionItem)
st = diagram.create(ClassItem,
subject=element_factory.create(UML.Stereotype))
cls = diagram.create(ClassItem, subject=element_factory.create(UML.Class))
connect(ext, ext.tail, st)
connect(ext, ext.head, cls)
assert ext.subject.package is pkg
def test_generalization_connection(create):
"""Test generalization item connection using two classes."""
gen = create(GeneralizationItem)
c1 = create(ClassItem, UML.Class)
c2 = create(ClassItem, UML.Class)
connect(gen, gen.tail, c1)
assert get_connected(gen, gen.tail) is c1
connect(gen, gen.head, c2)
assert gen.subject is not None
assert gen.subject.general is c2.subject
assert gen.subject.specific is c1.subject
def test_dependency_glue(create):
"""Test dependency glue to two actor items."""
actor1 = create(ActorItem, UML.Actor)
actor2 = create(ActorItem, UML.Actor)
dep = create(DependencyItem)
glued = allow(dep, dep.head, actor1)
assert glued
connect(dep, dep.head, actor1)
glued = allow(dep, dep.tail, actor2)
assert glued
def two_classes_and_an_association(diagram, element_factory):
gen_cls = element_factory.create(UML.Class)
spc_cls = element_factory.create(UML.Class)
gen_cls_item = diagram.create(ClassItem, subject=gen_cls)
spc_cls_item = diagram.create(ClassItem, subject=spc_cls)
assoc_item = diagram.create(AssociationItem)
connect(assoc_item, assoc_item.handles()[0], gen_cls_item)
connect(assoc_item, assoc_item.handles()[1], spc_cls_item)
UML.model.set_navigability(assoc_item.subject,
assoc_item.subject.memberEnd[0], True)
return gen_cls_item, spc_cls_item, assoc_item
def metaclass_stereotype_and_extension(diagram, element_factory):
m_cls = element_factory.create(UML.Class)
st_cls = element_factory.create(UML.Stereotype)
m_cls_item = diagram.create(ClassItem, subject=m_cls)
st_cls_item = diagram.create(ClassItem, subject=st_cls)
ext_item = diagram.create(ExtensionItem)
m_cls.name = "Class"
st_cls.name = "Stereotype"
connect(ext_item, ext_item.handles()[0], m_cls_item)
connect(ext_item, ext_item.handles()[1], st_cls_item)
return m_cls_item, st_cls_item, ext_item
def test_commentline_element_disconnect(create, diagram):
"""Test comment line connecting to comment and disconnecting actor item."""
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
ac = create(ActorItem, UML.Actor)
connect(line, line.head, comment)
connect(line, line.tail, ac)
assert diagram.canvas.get_connection(line.tail).connected is ac
disconnect(line, line.tail)
assert not diagram.canvas.get_connection(line.tail)
def test_message_connect_to_execution_specification(diagram, element_factory):
"""Test gluing message on sequence diagram."""
lifeline = diagram.create(LifelineItem,
subject=element_factory.create(UML.Lifeline))
exec_spec = diagram.create(ExecutionSpecificationItem)
message = diagram.create(MessageItem)
connect(exec_spec,
exec_spec.handles()[0], lifeline, lifeline.lifetime.port)
connect(message, message.head, exec_spec, exec_spec.ports()[0])
assert message.subject
assert message.subject.sendEvent.covered is lifeline.subject
def test_generalization_reconnection(create, element_factory):
"""Test generalization item connection using two classes.
On reconnection a new Generalization is created.
"""
gen = create(GeneralizationItem)
c1 = create(ClassItem, UML.Class)
c2 = create(ClassItem, UML.Class)
connect(gen, gen.tail, c1)
assert get_connected(gen, gen.tail) is c1
connect(gen, gen.head, c2)
assert gen.subject is not None
assert gen.subject.general is c2.subject
assert gen.subject.specific is c1.subject
# Now do the same on a new diagram:
diagram2 = element_factory.create(UML.Diagram)
c3 = diagram2.create(ClassItem, subject=c1.subject)
c4 = diagram2.create(ClassItem, subject=c2.subject)
gen2 = diagram2.create(GeneralizationItem)
connect(gen2, gen2.head, c3)
cinfo = diagram2.connections.get_connection(gen2.head)
assert cinfo is not None
assert cinfo.connected is c3
connect(gen2, gen2.tail, c4)
assert gen.subject is not gen2.subject
assert len(c1.subject.generalization) == 1
assert c1.subject.generalization[0] is gen.subject
def test_message_is_owned_by_implicit_interaction_connecting_to_head(
diagram, element_factory, end_name):
"""Test messages' lifetimes connection."""
interaction = element_factory.create(UML.Interaction)
msg = diagram.create(MessageItem)
ll = diagram.create(LifelineItem,
subject=element_factory.create(UML.Lifeline))
ll.subject.interaction = interaction
connect(msg, getattr(msg, end_name), ll)
assert msg.subject is not None
assert msg.subject.interaction is interaction
assert msg.parent is None
def test_connect_execution_specification_to_execution_specification(
diagram, element_factory):
parent_exec_spec = diagram.create(ExecutionSpecificationItem)
child_exec_spec = diagram.create(ExecutionSpecificationItem)
connect(
child_exec_spec,
child_exec_spec.handles()[0],
parent_exec_spec,
parent_exec_spec.ports()[0],
)
assert not parent_exec_spec.subject
assert not child_exec_spec.subject
def test_dependency_type_auto(create, element_factory):
"""Test dependency type automatic determination."""
cls = create(ClassItem, UML.Class)
iface = create(InterfaceItem, UML.Interface)
dep = create(DependencyItem)
assert dep.auto_dependency
connect(dep, dep.tail, cls) # connect client
connect(dep, dep.head, iface) # connect supplier
assert dep.subject is not None
assert isinstance(dep.subject, UML.Usage), dep.subject
assert dep.subject in element_factory.select()
def test_copy_item_without_copying_connection(diagram, element_factory):
cls = element_factory.create(UML.Class)
cls_item = diagram.create(ClassItem, subject=cls)
gen_item = diagram.create(GeneralizationItem)
connect(gen_item, gen_item.handles()[0], cls_item)
buffer = copy({cls_item})
new_items = paste(buffer, diagram, element_factory.lookup)
assert len(diagram.canvas.get_root_items()) == 3
assert len(element_factory.lselect(UML.Class)) == 1
assert type(new_items) is set
assert len(new_items) == 1
def test_commentline_relationship_unlink(create):
"""Test comment line to a relationship item connection and unlink.
Demonstrates defect #103.
"""
clazz1 = create(ClassItem, UML.Class)
clazz2 = create(ClassItem, UML.Class)
gen = create(GeneralizationItem)
connect(gen, gen.head, clazz1)
connect(gen, gen.tail, clazz2)
assert gen.subject
# now, connect comment to a generalization (relationship)
comment = create(CommentItem, Comment)
line = create(CommentLineItem)
connect(line, line.head, comment)
connect(line, line.tail, gen)
assert gen.subject in comment.subject.annotatedElement
assert comment.subject in gen.subject.comment
gen.unlink()
assert not comment.subject.annotatedElement
assert gen.subject is None
def test_connect_execution_specification_to_lifeline(diagram, element_factory):
lifeline = diagram.create(LifelineItem,
subject=element_factory.create(UML.Lifeline))
lifeline.lifetime.visible = True
exec_spec = diagram.create(ExecutionSpecificationItem)
connect(exec_spec,
exec_spec.handles()[0], lifeline, lifeline.lifetime.port)
assert exec_spec.subject
assert lifeline.subject
assert exec_spec.subject.start.covered is lifeline.subject
assert (exec_spec.subject.executionOccurrenceSpecification[0].covered is
lifeline.subject)
def test_association_item_reconnect(connected_association, create):
asc, c1, c2 = connected_association
c3 = create(ClassItem, UML.Class)
UML.model.set_navigability(asc.subject, asc.tail_subject, True)
a = asc.subject
connect(asc, asc.tail, c3)
assert a is asc.subject
ends = [p.type for p in asc.subject.memberEnd]
assert c1.subject in ends
assert c3.subject in ends
assert c2.subject not in ends
assert asc.tail_subject.navigability is True
def test_glue(element_factory, diagram):
"""Test extension item glue."""
ext = diagram.create(ExtensionItem)
st = diagram.create(ClassItem,
subject=element_factory.create(UML.Stereotype))
cls = diagram.create(ClassItem, subject=element_factory.create(UML.Class))
glued = allow(ext, ext.tail, st)
assert glued
connect(ext, ext.tail, st)
glued = allow(ext, ext.head, cls)
assert glued
