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