def test_copy_remove_and_paste_partition_item(partition_item, diagram,
element_factory):
copy_clear_and_paste({partition_item}, diagram, element_factory)
new_item = diagram.ownedPresentation[0]
assert new_item.subject in new_item.partition
assert len(new_item.partition) == 2
def test_cut_paste_of_stereotype(diagram, element_factory):
m_cls_item, st_cls_item, ext_item = metaclass_stereotype_and_extension(
diagram, element_factory)
copy_clear_and_paste({m_cls_item, st_cls_item, ext_item}, diagram,
element_factory)
new_m_cls = next(element_factory.select(lambda e: e.name == "Class"))
new_st_cls = next(element_factory.select(lambda e: e.name == "Stereotype"))
new_ext = next(element_factory.select(UML.Extension))
assert new_m_cls in new_ext.memberEnd[:].type
assert new_st_cls in new_ext.memberEnd[:].type
assert new_st_cls is new_ext.ownedEnd.type
def test_copy_remove_paste_items_when_namespace_is_removed(diagram, element_factory):
package = element_factory.create(UML.Package)
cls = element_factory.create(UML.Class)
cls.package = package
cls_item = diagram.create(ClassItem, subject=cls)
diagram_package = element_factory.create(UML.Package)
diagram.package = diagram_package
copy_clear_and_paste({cls_item}, diagram, element_factory, retain=[diagram_package])
new_cls = element_factory.lselect(UML.Class)[0]
assert new_cls.namespace is diagram_package
def test_execution_specification(diagram, element_factory):
lifeline_item, exec_spec_item = create_lifeline_with_execution_specification(
diagram, element_factory)
copy_clear_and_paste({lifeline_item, exec_spec_item}, diagram,
element_factory)
new_exec_spec: UML.ExecutionSpecification = element_factory.lselect(
lambda e: isinstance(e, UML.ExecutionSpecification))[0]
new_lifeline: UML.Lifeline = element_factory.lselect(
lambda e: isinstance(e, UML.Lifeline))[0]
assert (new_lifeline.coveredBy[0] is
new_exec_spec.executionOccurrenceSpecification[0])
assert (new_lifeline.coveredBy[1] is
new_exec_spec.executionOccurrenceSpecification[1])
def test_copy_remove_paste_of_item_with_nested_item(diagram, element_factory,
node_with_component):
new_items = copy_clear_and_paste(set(node_with_component), diagram,
element_factory)
new_node_item = next(i for i in new_items if isinstance(i, NodeItem))
new_comp_item = next(i for i in new_items if isinstance(i, ComponentItem))
assert diagram.canvas.get_parent(new_comp_item) is new_node_item
def test_copy_remove_paste_simple_items(diagram, element_factory):
box = diagram.create(Box)
ellipse = diagram.create(Ellipse)
line = diagram.create(Line)
new_items = copy_clear_and_paste({box, ellipse, line}, diagram, element_factory)
new_box = next(item for item in new_items if isinstance(item, Box))
assert new_box
def test_connector(diagram, element_factory):
comp = element_factory.create(UML.Component)
iface = element_factory.create(UML.Interface)
comp_item = diagram.create(ComponentItem, subject=comp)
iface_item = diagram.create(InterfaceItem, subject=iface)
conn_item = diagram.create(ConnectorItem)
connect(conn_item, conn_item.handles()[0], comp_item)
connect(conn_item, conn_item.handles()[1], iface_item)
copy_clear_and_paste({comp_item, iface_item, conn_item}, diagram, element_factory)
new_conn = element_factory.lselect(lambda e: isinstance(e, UML.Connector))[0]
new_comp = element_factory.lselect(lambda e: isinstance(e, UML.Component))[0]
new_iface = element_factory.lselect(lambda e: isinstance(e, UML.Interface))[0]
assert isinstance(new_conn.presentation[0], ConnectorItem)
assert new_conn.kind == "assembly"
assert len(new_conn.end) == 1
assert new_conn.end[0].role is new_iface
assert new_conn.end[0].partWithPort in new_comp.ownedPort
def test_class_with_attributes(diagram, element_factory):
cls = element_factory.create(UML.Class)
attr = element_factory.create(UML.Property)
UML.parse(attr, "- attr: str")
cls.ownedAttribute = attr
cls_item = diagram.create(ClassItem, subject=cls)
new_items = copy_clear_and_paste({cls_item}, diagram, element_factory)
new_cls_item = new_items.pop()
assert isinstance(new_cls_item, ClassItem)
assert UML.format(new_cls_item.subject.ownedAttribute[0]) == "- attr: str"
def test_message(diagram, element_factory):
lifeline1 = element_factory.create(UML.Lifeline)
lifeline2 = element_factory.create(UML.Lifeline)
lifeline1_item = diagram.create(LifelineItem, subject=lifeline1)
lifeline2_item = diagram.create(LifelineItem, subject=lifeline2)
message_item = diagram.create(MessageItem)
connect(message_item, message_item.handles()[0], lifeline1_item)
connect(message_item, message_item.handles()[1], lifeline2_item)
copy_clear_and_paste({lifeline1_item, lifeline2_item, message_item},
diagram, element_factory)
new_message: UML.Message = element_factory.lselect(
lambda e: isinstance(e, UML.Message))[0]
new_lifelines = element_factory.lselect(
lambda e: isinstance(e, UML.Lifeline))
assert new_message.sendEvent.covered in new_lifelines
assert new_message.receiveEvent.covered in new_lifelines
assert new_message.sendEvent.covered is not new_message.receiveEvent.covered
def test_copy_remove_paste_items_with_connections(diagram, element_factory):
gen_cls_item, spc_cls_item, gen_item = two_classes_and_a_generalization(
diagram, element_factory)
new_items = copy_clear_and_paste({gen_cls_item, gen_item, spc_cls_item},
diagram, element_factory)
new_cls1, new_cls2 = element_factory.lselect(UML.Class)
new_gen = element_factory.lselect(UML.Generalization)[0]
assert new_gen.general in {new_cls1, new_cls2}
assert new_gen.specific in {new_cls1, new_cls2}
assert new_cls1.presentation[0] in new_items
assert new_cls2.presentation[0] in new_items
assert new_gen.presentation[0] in new_items
def test_class_with_operation(diagram, element_factory):
cls = element_factory.create(UML.Class)
oper = element_factory.create(UML.Operation)
UML.parse(oper, "- oper(inout param: str): str")
cls.ownedOperation = oper
cls_item = diagram.create(ClassItem, subject=cls)
new_items = copy_clear_and_paste({cls_item}, diagram, element_factory)
new_cls_item = new_items.pop()
assert isinstance(new_cls_item, ClassItem)
assert (UML.format(new_cls_item.subject.ownedOperation[0]) ==
"- oper(inout param: str): str")
def test_copy_remove_paste_items_with_connections(diagram, element_factory):
gen_cls_item, spc_cls_item, assoc_item = two_classes_and_an_association(
diagram, element_factory)
new_items = copy_clear_and_paste({gen_cls_item, assoc_item, spc_cls_item},
diagram, element_factory)
new_cls1, new_cls2 = element_factory.lselect(UML.Class)
new_assoc = element_factory.lselect(UML.Association)[0]
assert new_assoc.memberEnd[0].type in {new_cls1, new_cls2}
assert new_assoc.memberEnd[1].type in {new_cls1, new_cls2}
assert new_assoc.memberEnd[0] in new_assoc.memberEnd[1].type.ownedAttribute
assert new_cls1.presentation[0] in new_items
assert new_cls2.presentation[0] in new_items
assert new_assoc.presentation[0] in new_items
def test_state_with_behaviors(diagram, element_factory):
state: UML.State = element_factory.create(UML.State)
state.entry = element_factory.create(UML.Behavior)
state.entry.name = "hi"
state.exit = element_factory.create(UML.Behavior)
state.exit.name = "bye"
state.doActivity = element_factory.create(UML.Behavior)
state.doActivity.name = "act"
state_item = diagram.create(StateItem, subject=state)
new_items = copy_clear_and_paste({state_item}, diagram, element_factory)
new_state_item = new_items.pop()
assert isinstance(new_state_item, StateItem)
assert new_state_item.subject.entry.name == "hi"
assert new_state_item.subject.exit.name == "bye"
assert new_state_item.subject.doActivity.name == "act"
def test_connected_transition(diagram, element_factory):
state_item_1 = diagram.create(StateItem,
subject=element_factory.create(UML.State))
state_item_2 = diagram.create(StateItem,
subject=element_factory.create(UML.State))
transition_item = diagram.create(TransitionItem)
connect(transition_item, transition_item.head, state_item_1)
connect(transition_item, transition_item.tail, state_item_2)
transition_item.subject.guard.specification = "[test]"
new_items = copy_clear_and_paste({transition_item}, diagram,
element_factory)
new_transition_item = new_items.pop()
assert isinstance(new_transition_item, TransitionItem), new_items
assert new_transition_item.subject.guard
assert new_transition_item.subject.guard.specification == "[test]"
def test_copy_remove_paste_items_with_connections(diagram, element_factory):
gen_cls_item, spc_cls_item, assoc_item = two_classes_and_an_association(
diagram, element_factory)
new_items = copy_clear_and_paste({gen_cls_item, assoc_item, spc_cls_item},
diagram, element_factory)
new_cls1 = next(element_factory.select(lambda e: e.name == "Gen"))
new_cls2 = next(element_factory.select(lambda e: e.name == "Spc"))
new_assoc = next(element_factory.select(UML.Association))
assert new_assoc.memberEnd[0].type is new_cls1
assert new_assoc.memberEnd[1].type is new_cls2
assert new_assoc.memberEnd[0] in new_assoc.memberEnd[1].type.ownedAttribute
assert new_cls1.presentation[0] in new_items
assert new_cls2.presentation[0] in new_items
assert new_assoc.presentation[0] in new_items
assert new_assoc.presentation[0].head_subject
assert new_assoc.presentation[0].tail_subject
def test_interface_with_attributes_and_operation(diagram, element_factory):
iface = element_factory.create(UML.Interface)
attr = element_factory.create(UML.Property)
parse(attr, "- attr: str")
iface.ownedAttribute = attr
oper = element_factory.create(UML.Operation)
parse(oper, "- oper(inout param: str): str")
iface.ownedOperation = oper
iface_item = diagram.create(InterfaceItem, subject=iface)
new_items = copy_clear_and_paste({iface_item}, diagram, element_factory)
new_iface_item = new_items.pop()
assert isinstance(new_iface_item, InterfaceItem)
assert format(new_iface_item.subject.ownedAttribute[0]) == "- attr: str"
assert (format(new_iface_item.subject.ownedOperation[0]) ==
"- oper(inout param: str): str")
