def test_extension_deletion_with_2_metaclasses(self):
factory = self.element_factory
create = factory.create
# Set the stage
metaklass = create(uml2.Class)
metaklass.name = 'Class'
metaiface = create(uml2.Class)
metaiface.name = 'Interface'
klass = create(uml2.Class)
iface = create(uml2.Interface)
stereotype = create(uml2.Stereotype)
st_attr = self.element_factory.create(uml2.Property)
stereotype.ownedAttribute = st_attr
ext1 = modelfactory.create_extension(factory, metaklass, stereotype)
ext2 = modelfactory.create_extension(factory, metaiface, stereotype)
# Apply stereotype to class and create slot
instspec1 = modelfactory.apply_stereotype(factory, klass, stereotype)
instspec2 = modelfactory.apply_stereotype(factory, iface, stereotype)
slot = modelfactory.add_slot(factory, instspec1, st_attr)
self.assertTrue(stereotype in klass.appliedStereotype[:].classifier)
self.assertTrue(klass in self.element_factory)
ext1.unlink()
self.assertEquals([], list(klass.appliedStereotype))
self.assertTrue(klass in self.element_factory)
self.assertEquals([instspec2], list(iface.appliedStereotype))
def test_stereotype_attributes_status_saving(self):
"""Test stereotype attributes status saving
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
modelfactory.apply_stereotype(factory, c.subject, self.st1)
obj = modelfactory.apply_stereotype(factory, c.subject, self.st2)
# change attribute of 2nd stereotype
attr = self.st2.ownedAttribute[0]
slot = modelfactory.add_slot(self.element_factory, obj, attr)
slot.value = 'st2 test21'
data = self.save()
self.load(data)
item = self.diagram.canvas.select(
lambda e: isinstance(e, ComponentItem))[0]
self.assertTrue(item.show_stereotypes_attrs)
self.assertEqual(2, len(item._compartments))
# first stereotype has no attributes changed, so compartment
# invisible
self.assertFalse(item._compartments[0].visible)
self.assertTrue(item._compartments[1].visible)
def test_applying_stereotype(self):
"""Test if stereotype compartment is created when stereotype is applied
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
# test precondition
self.assertEqual(0, len(c._compartments))
c.show_stereotypes_attrs = True
modelfactory.apply_stereotype(factory, c.subject, self.st1)
self.assertEqual(1, len(c._compartments))
self.assertFalse(c._compartments[0].visible)
def test_removing_stereotype(self):
"""Test if stereotype compartment is destroyed when stereotype is removed
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
modelfactory.apply_stereotype(factory, c.subject, self.st1)
# test precondition
self.assertEqual(1, len(c._compartments))
modelfactory.remove_stereotype(c.subject, self.st1)
self.assertEqual(0, len(c._compartments))
def test_stereotype_attribute_delete(self):
"""
This test was applicable to the Sanitizer service, but is now resolved
by a tweak in the data model (Instances diagram).
"""
factory = self.element_factory
create = factory.create
# Set the stage
# metaklass = create(uml2.Class)
# metaklass.name = 'Class'
klass = create(uml2.Class)
stereotype = create(uml2.Stereotype)
st_attr = self.element_factory.create(uml2.Property)
stereotype.ownedAttribute = st_attr
# ext = modelfactory.create_extension(factory, metaklass, stereotype)
# Apply stereotype to class and create slot
instspec = modelfactory.apply_stereotype(factory, klass, stereotype)
slot = modelfactory.add_slot(factory, instspec, st_attr)
# Now, what happens if the attribute is deleted:
self.assertTrue(st_attr in stereotype.ownedMember)
self.assertTrue(slot in instspec.slot)
st_attr.unlink()
self.assertEquals([], list(stereotype.ownedMember))
self.assertEquals([], list(instspec.slot))
def test_removing_stereotype_attribute(self):
"""Test if stereotype instance specification is destroyed when stereotype attribute is removed
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
# test precondition
self.assertEqual(0, len(c._compartments))
obj = modelfactory.apply_stereotype(factory, c.subject, self.st1)
# test precondition
self.assertEqual(1, len(c._compartments))
self.assertEqual(0, len(self.kindof(uml2.Slot)))
attr = self.st1.ownedAttribute[0]
slot = modelfactory.add_slot(factory, obj, attr)
self.assertEqual(1, len(obj.slot))
self.assertEqual(1, len(self.kindof(uml2.Slot)))
self.assertTrue(slot.definingFeature)
compartment = c._compartments[0]
self.assertTrue(compartment.visible)
attr.unlink()
self.assertEqual(0, len(obj.slot))
self.assertEqual(0, len(self.kindof(uml2.Slot)))
self.assertFalse(compartment.visible)
def test_saving_stereotype_attributes(self):
"""Test stereotype attributes saving
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
modelfactory.apply_stereotype(factory, c.subject, self.st1)
modelfactory.apply_stereotype(factory, c.subject, self.st2)
self.assertEqual(3, len(self.st1.ownedAttribute))
attr1, attr2, attr3 = self.st1.ownedAttribute
self.assertEqual(attr1.name, 'st1_attr_1', attr1.name)
self.assertEqual(attr2.name, 'st1_attr_2', attr2.name)
self.assertEqual(attr3.name, 'baseClass', attr3.name)
obj = c.subject.appliedStereotype[0]
slot = modelfactory.add_slot(self.element_factory, obj, attr1)
slot.value = 'st1 test1'
slot = modelfactory.add_slot(self.element_factory, obj, attr2)
slot.value = 'st1 test2'
data = self.save()
self.load(data)
item = self.diagram.canvas.select(
lambda e: isinstance(e, ComponentItem))[0]
el = item.subject
self.assertEqual(2, len(el.appliedStereotype))
# check if stereotypes are properly applied
names = sorted(obj.classifier[0].name for obj in el.appliedStereotype)
self.assertEqual(['st1', 'st2'], names)
# two attributes were changed for stereotype st1, so 2 slots
obj = el.appliedStereotype[0]
self.assertEqual(2, len(obj.slot))
self.assertEqual('st1_attr_1', obj.slot[0].definingFeature.name)
self.assertEqual('st1 test1', obj.slot[0].value)
self.assertEqual('st1_attr_2', obj.slot[1].definingFeature.name)
self.assertEqual('st1 test2', obj.slot[1].value)
# no stereotype st2 attribute changes, no slots
obj = el.appliedStereotype[1]
self.assertEqual(0, len(obj.slot))
def test_deleting_stereotype(self):
"""Test if stereotype is removed when stereotype is deleted
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
st1 = self.st1
modelfactory.apply_stereotype(factory, c.subject, st1)
# test precondition
self.assertEqual(1, len(c._compartments))
self.assertEqual(1, len(c.subject.appliedStereotype))
st1.unlink()
self.assertEqual(0, len(c.subject.appliedStereotype))
self.assertEqual(0, len(c._compartments))
def select_stereotype(self, iter):
"""
Select the stereotype.
"""
path = self.get_path(iter)
row = self[path]
name, old_value, is_applied, stereotype, _, _ = row
value = not is_applied
log.debug('selecting %s' % list(row))
subject = self.subject
if value:
modelfactory.apply_stereotype(self.element_factory, subject,
stereotype)
else:
modelfactory.remove_stereotype(subject, stereotype)
row[2] = value
# TODO: change refresh in a refresh of the data model, rather than a clear-refresh
self.refresh()
def test_removing_last_slot(self):
"""Test removing last slot
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
obj = modelfactory.apply_stereotype(factory, c.subject, self.st1)
slot = modelfactory.add_slot(factory, obj, self.st1.ownedAttribute[0])
compartment = c._compartments[0]
# test precondition
self.assertTrue(compartment.visible)
del obj.slot[slot]
self.assertFalse(compartment.visible)
def test_adding_slot(self):
"""Test if stereotype attribute information is added when slot is added
"""
factory = self.element_factory
c = self.create(ComponentItem, uml2.Component)
c.show_stereotypes_attrs = True
obj = modelfactory.apply_stereotype(factory, c.subject, self.st1)
# test precondition
self.assertFalse(c._compartments[0].visible)
slot = modelfactory.add_slot(factory, obj, self.st1.ownedAttribute[0])
compartment = c._compartments[0]
self.assertTrue(compartment.visible)
self.assertEqual(1, len(compartment), slot)
def test_stereotypes_conversion(self):
"""Test stereotypes conversion
"""
s1 = self.factory.create(uml2.Stereotype)
s2 = self.factory.create(uml2.Stereotype)
s3 = self.factory.create(uml2.Stereotype)
s1.name = 's1'
s2.name = 's2'
s3.name = 's3'
cls = self.factory.create(uml2.Class)
modelfactory.apply_stereotype(self.factory, cls, s1)
modelfactory.apply_stereotype(self.factory, cls, s2)
modelfactory.apply_stereotype(self.factory, cls, s3)
self.assertEquals(fmt % 's1, s2, s3', modelfactory.stereotypes_str(cls))
def test_stereotype_deletion(self):
factory = self.element_factory
create = factory.create
# Set the stage
metaklass = create(uml2.Class)
metaklass.name = 'Class'
klass = create(uml2.Class)
stereotype = create(uml2.Stereotype)
st_attr = self.element_factory.create(uml2.Property)
stereotype.ownedAttribute = st_attr
ext = modelfactory.create_extension(factory, metaklass, stereotype)
# Apply stereotype to class and create slot
instspec = modelfactory.apply_stereotype(factory, klass, stereotype)
slot = modelfactory.add_slot(factory, instspec, st_attr)
self.assertTrue(stereotype in klass.appliedStereotype[:].classifier)
stereotype.unlink()
self.assertEquals([], list(klass.appliedStereotype))
def test_additional_stereotypes(self):
"""Test additional stereotypes conversion
"""
s1 = self.factory.create(uml2.Stereotype)
s2 = self.factory.create(uml2.Stereotype)
s3 = self.factory.create(uml2.Stereotype)
s1.name = 's1'
s2.name = 's2'
s3.name = 's3'
cls = self.factory.create(uml2.Class)
modelfactory.apply_stereotype(self.factory, cls, s1)
modelfactory.apply_stereotype(self.factory, cls, s2)
modelfactory.apply_stereotype(self.factory, cls, s3)
result = modelfactory.stereotypes_str(cls, ('test',))
self.assertEquals(fmt % 'test, s1, s2, s3', result)
def test_finding_stereotype_instances(self):
"""Test finding stereotype instances
"""
s1 = self.factory.create(uml2.Stereotype)
s2 = self.factory.create(uml2.Stereotype)
s1.name = 's1'
s2.name = 's2'
c1 = self.factory.create(uml2.Class)
c2 = self.factory.create(uml2.Class)
modelfactory.apply_stereotype(self.factory, c1, s1)
modelfactory.apply_stereotype(self.factory, c1, s2)
modelfactory.apply_stereotype(self.factory, c2, s1)
result = [e.classifier[0].name for e in modelfactory.find_instances(self.factory, s1)]
self.assertEquals(2, len(result))
self.assertTrue('s1' in result, result)
self.assertFalse('s2' in result, result)
def version_0_15_0_post(elements, factory, gaphor_version):
"""
Part two: create stereotypes and what more for the elements that have a
taggedvalue property.
"""
def update_elements(element):
e = elements[element.id] = parser.element(element.id, element.__class__.__name__)
e.element = element
if version_lower_than(gaphor_version, (0, 14, 99)):
stereotypes = {}
profile = None
for e in elements.values():
if hasattr(e, 'taggedvalue'):
if not profile:
profile = factory.create(uml2.Profile)
profile.name = 'version 0.15 conversion'
update_elements(profile)
st = stereotypes.get(e.type)
if not st:
st = stereotypes[e.type] = factory.create(uml2.Stereotype)
st.name = 'Tagged'
st.package = profile
update_elements(st)
cl = factory.create(uml2.Class)
cl.name = str(e.type)
cl.package = profile
update_elements(cl)
ext = modelfactory.extend_with_stereotype(factory, cl, st)
update_elements(ext)
for me in ext.memberEnd:
update_elements(me)
# Create instance specification for the stereotype:
instspec = modelfactory.apply_stereotype(factory, e.element, st)
update_elements(instspec)
def create_slot(key, val):
for attr in st.ownedAttribute:
if attr.name == key:
break
else:
attr = st.ownedAttribute = factory.create(uml2.Property)
attr.name = str(key)
update_elements(attr)
slot = modelfactory.add_slot(factory, instspec, attr)
slot.value.value = str(val)
update_elements(slot)
tviter = iter(e.taggedvalue or [])
for tv in tviter:
try:
try:
key, val = tv.split('=', 1)
key = key.strip()
except ValueError:
log.info('Tagged value "%s" has no key=value format, trying key_value ' % tv)
try:
key, val = tv.split(' ', 1)
key = key.strip()
except ValueError:
# Fallback, deal with it as if it were a boolean
key = tv.strip()
val = 'true'
# This syntax is used with the uml2 meta model:
if key in ('subsets', 'redefines'):
rest = ', '.join(tviter)
val = ', '.join([val, rest]) if rest else val
val = val.replace('\n', ' ')
log.info('Special case: UML metamodel "%s %s"' % (key, val))
create_slot(key, val)
except Exception as e:
log.warning('Unable to process tagged value "%s" as key=value pair' % tv, exc_info=True)
def find(messages, attr):
occurrences = set(getattr(m, attr) for m in messages
if hasattr(m, attr) and getattr(m, attr))
assert len(occurrences) <= 1
if occurrences:
return occurrences.pop()
else:
return None
def update_msg(msg, sl, rl):
if sl:
s = factory.create(uml2.MessageOccurrenceSpecification)
s.covered = sl
m.sendEvent = s
if rl:
r = factory.create(uml2.MessageOccurrenceSpecification)
r.covered = rl
m.receiveEvent = r
for e in elements.values():
if e.type == 'MessageItem':
msg = e.element
send = msg.subject.sendEvent
receive = msg.subject.receiveEvent
if not send:
send = find(list(msg._messages.keys()), 'sendEvent')
if not receive:
receive = find(list(msg._messages.keys()), 'receiveEvent')
if not send:
send = find(list(msg._inverted_messages.keys()), 'reveiveEvent')
if not receive:
receive = find(list(msg._inverted_messages.keys()), 'sendEvent')
sl = send.covered if send else None
rl = receive.covered if receive else None
for m in msg._messages:
update_msg(m, sl, rl)
for m in msg._inverted_messages:
update_msg(m, rl, sl)
msg.subject.sendEvent = send
msg.subject.receiveEvent = receive
