def test_show_diagram(self):
main_w = Application.get_service("main_window")
element_factory = Application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
main_w.open()
self.component_registry.handle(DiagramShow(diagram))
self.assertEqual(self.get_current_diagram(), diagram)
def test_show_diagram(self):
main_w = Application.get_service("main_window")
element_factory = Application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
main_w.open()
self.component_registry.handle(DiagramShow(diagram))
self.assertEqual(self.get_current_diagram(), diagram)
def test_service_load(self):
"""Test loading services and querying utilities."""
Application.init(["undo_manager", "file_manager", "properties"])
self.assertTrue(
Application.get_service("undo_manager") is not None,
"Failed to load the undo manager service",
)
self.assertTrue(
Application.get_service("file_manager") is not None,
"Failed to load the file manager service",
)
self.assertTrue(
component.queryUtility(IService, "undo_manager") is not None,
"Failed to query the undo manager utility",
)
self.assertTrue(
component.queryUtility(IService, "file_manager") is not None,
"Failed to query the file manager utility",
)
Application.shutdown()
def launch(model=None):
"""Start the main application by initiating and running Application.
The file_manager service is used here to load a Gaphor model if one was
specified on the command line. Otherwise, a new model is created and
the Gaphor GUI is started."""
# Make sure gui is loaded ASAP.
# This prevents menu items from appearing at unwanted places.
Application.essential_services.append('main_window')
Application.init()
main_window = Application.get_service('main_window')
main_window.open()
file_manager = Application.get_service('file_manager')
if model:
file_manager.load(model)
else:
file_manager.action_new()
Application.run()
def launch(model=None):
"""Start the main application by initiating and running Application.
The file_manager service is used here to load a Gaphor model if one was
specified on the command line. Otherwise, a new model is created and
the Gaphor GUI is started."""
# Make sure gui is loaded ASAP.
# This prevents menu items from appearing at unwanted places.
Application.essential_services.append('main_window')
Application.init()
main_window = Application.get_service('main_window')
main_window.open()
file_manager = Application.get_service('file_manager')
if model:
file_manager.load(model)
else:
file_manager.action_new()
Application.run()
def setUp(self):
Application.init(services=[
"event_manager",
"component_registry",
"element_factory",
"main_window",
"action_manager",
"properties",
"namespace",
"diagrams",
"toolbox",
])
main_window = Application.get_service("main_window")
main_window.open()
self.element_factory = Application.get_service("element_factory")
self.diagram = self.element_factory.create(UML.Diagram)
self.page = DiagramPage(
self.diagram,
Application.get_service("event_manager"),
self.element_factory,
Application.get_service("properties"),
)
self.page.construct()
assert self.page.diagram == self.diagram
assert self.page.view.canvas == self.diagram.canvas
assert len(self.element_factory.lselect()) == 1
def test_show_diagram(self):
main_w = Application.get_service('main_window')
element_factory = Application.get_service('element_factory')
diagram = element_factory.create(UML.Diagram)
main_w.open()
self.assertEqual(main_w.get_current_diagram(), None)
main_w.show_diagram(diagram)
def test_show_diagram(self):
main_w = Application.get_service('main_window')
element_factory = Application.get_service('element_factory')
diagram = element_factory.create(UML.Diagram)
main_w.open()
self.assertEqual(main_w.get_current_diagram(), None)
main_w.show_diagram(diagram)
def element_factory():
Application.init()
element_factory = Application.get_service("element_factory")
dist = importlib_metadata.distribution("gaphor")
path = dist.locate_file("test-diagrams/issue_53.gaphor")
load(path, element_factory)
yield element_factory
Application.get_service("element_factory").shutdown()
Application.shutdown()
def setUp(self):
Application.init(services=['adapter_loader', 'element_factory', 'main_window', 'properties_manager', 'action_manager', 'properties', 'element_dispatcher'])
self.main_window = Application.get_service('main_window')
self.element_factory = Application.get_service('element_factory')
self.diagram = self.element_factory.create(UML.Diagram)
self.comment = self.diagram.create(CommentItem,
subject=self.element_factory.create(UML.Comment))
self.commentline = self.diagram.create(CommentLineItem)
self.view = self.main_window.show_diagram(self.diagram).view
def _action_opening(action, obj, name):
"""
Open a new UI component if it is returned from the opening action.
Otherwise do nothing.
"""
method = getattr(obj, name)
ui_comp = method()
if ui_comp:
Application.get_service('main_window').create_item(ui_comp)
def setUp(self):
Application.init(services=['element_factory', 'main_window', 'ui_manager', 'action_manager', 'properties', 'element_dispatcher'])
main_window = Application.get_service('main_window')
main_window.open()
element_factory = Application.get_service('element_factory')
self.element_factory = element_factory
self.diagram = element_factory.create(UML.Diagram)
self.tab = main_window.show_diagram(self.diagram)
self.assertEquals(self.tab.diagram, self.diagram)
self.assertEquals(self.tab.view.canvas, self.diagram.canvas)
self.assertEquals(len(element_factory.lselect()), 1)
def setUp(self):
Application.init(services=['element_factory', 'main_window', 'ui_manager', 'action_manager', 'properties', 'element_dispatcher'])
main_window = Application.get_service('main_window')
main_window.open()
element_factory = Application.get_service('element_factory')
self.element_factory = element_factory
self.diagram = element_factory.create(uml2.Diagram)
self.tab = main_window.show_diagram(self.diagram)
self.assertEquals(self.tab.diagram, self.diagram)
self.assertEquals(self.tab.view.canvas, self.diagram.canvas)
self.assertEquals(len(element_factory.lselect()), 1)
def element_factory():
Application.init(
services=["event_manager", "component_registry", "element_factory"])
event_manager = Application.get_service("event_manager")
event_manager.subscribe(handler)
clear_events()
factory = Application.get_service("element_factory")
yield factory
del factory
clear_events()
Application.shutdown()
def test_service_load():
"""Test loading services and querying utilities."""
Application.init()
assert (Application.get_service("undo_manager")
is not None), "Failed to load the undo manager service"
assert (Application.get_service("file_manager")
is not None), "Failed to load the file manager service"
Application.shutdown()
def testDiagramLayout(self):
elemfact = Application.get_service('element_factory')
diagram_layout = Application.get_service('diagram_layout')
diagram = elemfact.create(UML.Diagram)
c1 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class))
c2 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class))
c2.matrix.translate(100, 100)
c2.request_update()
diagram_layout.layout_diagram(diagram)
def testDiagramLayout(self):
elemfact = Application.get_service("element_factory")
diagram_layout = Application.get_service("diagram_layout")
diagram = elemfact.create(UML.Diagram)
c1 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class))
c2 = diagram.create(items.ClassItem, subject=elemfact.create(UML.Class))
c2.matrix.translate(100, 100)
c2.request_update()
diagram_layout.layout_diagram(diagram)
def setUp(self):
Application.init(services=['element_factory', 'main_window', 'action_manager', 'properties', 'element_dispatcher'])
main_window = Application.get_service('main_window')
element_factory = Application.get_service('element_factory')
self.element_factory = element_factory
self.diagram = element_factory.create(UML.Diagram)
self.tab = DiagramTab(main_window)
self.tab.set_diagram(self.diagram)
self.assertEquals(self.tab.diagram, self.diagram)
widget = self.tab.construct()
main_window.add_tab(self.tab, widget, 'title')
self.assertEquals(self.tab.view.canvas, self.diagram.canvas)
self.assertEquals(len(element_factory.lselect()), 1)
def test_service_load(self):
"""
Load services. At lease the undo_manager should be available after that.
"""
Application.init(['undo_manager', 'file_manager', 'properties'])
self.assertTrue(Application.get_service('undo_manager') is not None)
self.assertTrue(Application.get_service('file_manager') is not None)
# After that, services are also available as Utilities:
self.assertTrue(component.queryUtility(IService, 'undo_manager') is not None)
self.assertTrue(component.queryUtility(IService, 'file_manager') is not None)
Application.shutdown()
def setUp(self):
Application.init(services=[
'file_manager', 'element_factory', 'properties', 'main_window',
'action_manager', 'ui_manager'
])
self.recent_files_backup = Application.get_service('properties').get(
'recent-files')
def application():
Application.init(services=[
"event_manager",
"component_registry",
"file_manager",
"element_factory",
"properties",
"main_window",
"action_manager",
])
recent_files_backup = Application.get_service("properties").get(
"recent-files")
yield Application
Application.get_service("properties").set("recent-files",
recent_files_backup)
Application.shutdown()
def test_service_load(self):
"""Test loading services and querying utilities."""
Application.init(["undo_manager", "file_manager", "properties"])
self.assertTrue(
Application.get_service("undo_manager") is not None,
"Failed to load the undo manager service",
)
self.assertTrue(
Application.get_service("file_manager") is not None,
"Failed to load the file manager service",
)
Application.shutdown()
def setUp(self):
Application.init(services=[
'adapter_loader', 'element_factory', 'main_window', 'ui_manager',
'properties_manager', 'action_manager', 'properties',
'element_dispatcher'
])
self.main_window = Application.get_service('main_window')
self.main_window.init()
self.main_window.open()
self.element_factory = Application.get_service('element_factory')
self.diagram = self.element_factory.create(UML.Diagram)
self.comment = self.diagram.create(CommentItem,
subject=self.element_factory.create(
UML.Comment))
self.commentline = self.diagram.create(CommentLineItem)
self.view = self.main_window.show_diagram(self.diagram).view
def test_service_load(self):
"""Test loading services and querying utilities."""
Application.init(['undo_manager', 'file_manager', 'properties'])
self.assertTrue(Application.get_service('undo_manager') is not None, 'Failed to load the undo manager service')
self.assertTrue(Application.get_service('file_manager') is not None, 'Failed to load the file manager service')
self.assertTrue(component.queryUtility(IService, 'undo_manager') is not None, (
'Failed to query the undo manager utility'))
self.assertTrue(component.queryUtility(IService, 'file_manager') is not None, (
'Failed to query the file manager utility'))
Application.shutdown()
def __get__(self, obj, class_=None):
"""
Resolve a dependency, but only if we're called from an object instance.
"""
if not obj:
return self
return Application.get_service(self._name)
def test_package_removal(element_factory):
# Load the application
element_factory = Application.get_service("element_factory")
# Find all profile instances
profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile))
# Check there is 1 profile
assert len(profiles) == 1
# Check the profile has 1 presentation
assert len(profiles[0].presentation) == 1
# Unlink the presentation
profiles[0].presentation[0].unlink()
assert not element_factory.lselect(lambda e: e.isKindOf(UML.Profile))
classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class))
assert len(classes) == 1
# Check if the link is really removed:
assert not classes[0].appliedStereotype
assert not element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification))
assert len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))) == 3
def testPackageRemoval(self):
# Load the application
element_factory = Application.get_service('element_factory')
# Find all profile instances
profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile))
# Check there is 1 profile
self.assertEquals(1, len(profiles))
# Check the profile has 1 presentation
self.assertEquals(1, len(profiles[0].presentation))
# Unlink the presentation
profiles[0].presentation[0].unlink()
self.assertFalse(
element_factory.lselect(lambda e: e.isKindOf(UML.Profile)))
classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class))
self.assertEquals(1, len(classes))
# Check if the link is really removed:
self.assertFalse(classes[0].appliedStereotype)
self.assertFalse(
element_factory.lselect(
lambda e: e.isKindOf(UML.InstanceSpecification)))
self.assertEquals(
3, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))))
def testPackageRemoval(self):
# Load the application
element_factory = Application.get_service("element_factory")
# Find all profile instances
profiles = element_factory.lselect(lambda e: e.isKindOf(UML.Profile))
# Check there is 1 profile
self.assertEqual(1, len(profiles))
# Check the profile has 1 presentation
self.assertEqual(1, len(profiles[0].presentation))
# Unlink the presentation
profiles[0].presentation[0].unlink()
self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.Profile)))
classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class))
self.assertEqual(1, len(classes))
# Check if the link is really removed:
self.assertFalse(classes[0].appliedStereotype)
self.assertFalse(
element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification))
)
self.assertEqual(
3, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram)))
)
def test_connect_comment_and_actor(self):
"""Test connect/disconnect on comment and actor using comment-line.
"""
element_factory = Application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
self.event_manager.handle(DiagramShow(diagram))
comment = diagram.create(CommentItem,
subject=element_factory.create(UML.Comment))
line = diagram.create(CommentLineItem)
view = self.get_diagram_view(diagram)
assert view, "View should be available here"
tool = ConnectHandleTool(view)
# Connect one end to the Comment:
handle = line.handles()[0]
tool.grab_handle(line, handle)
handle.pos = (0, 0)
sink = tool.glue(line, handle, handle.pos)
assert sink is not None
assert sink.item is comment
tool.connect(line, handle, handle.pos)
cinfo = diagram.canvas.get_connection(handle)
assert cinfo is not None, None
assert cinfo.item is line
assert cinfo.connected is comment
# Connect the other end to the Actor:
actor = diagram.create(ActorItem,
subject=element_factory.create(UML.Actor))
handle = line.handles()[-1]
tool.grab_handle(line, handle)
handle.pos = (0, 0)
sink = tool.glue(line, handle, handle.pos)
assert sink, f"No sink at {handle.pos}"
assert sink.item is actor
tool.connect(line, handle, handle.pos)
cinfo = view.canvas.get_connection(handle)
assert cinfo.item is line
assert cinfo.connected is actor
# Try to connect far away from any item will only do a full disconnect
self.assertEqual(len(comment.subject.annotatedElement), 1,
comment.subject.annotatedElement)
assert actor.subject in comment.subject.annotatedElement
sink = tool.glue(line, handle, (500, 500))
assert sink is None, sink
tool.connect(line, handle, (500, 500))
cinfo = view.canvas.get_connection(handle)
assert cinfo is None
def test_iconnect_2(self):
"""Test connect/disconnect on comment and actor using comment-line.
"""
element_factory = Application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
self.component_registry.handle(DiagramShow(diagram))
comment = diagram.create(
CommentItem, subject=element_factory.create(UML.Comment)
)
actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor))
line = diagram.create(CommentLineItem)
view = self.get_diagram_view(diagram)
assert view, "View should be available here"
tool = ConnectHandleTool(view)
# Connect one end to the Comment:
handle = line.handles()[0]
tool.grab_handle(line, handle)
comment_bb = view.get_item_bounding_box(comment)
handle.pos = (comment_bb.x1, comment_bb.y1)
sink = tool.glue(line, handle, handle.pos)
assert sink is not None
assert sink.item is comment
tool.connect(line, handle, handle.pos)
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo is not None, None)
self.assertTrue(cinfo.item is line)
self.assertTrue(cinfo.connected is comment)
# Connect the other end to the Actor:
handle = line.handles()[-1]
tool.grab_handle(line, handle)
actor_bb = view.get_item_bounding_box(actor)
handle.pos = actor_bb.x1, actor_bb.y1
sink = tool.glue(line, handle, handle.pos)
self.assertTrue(sink.item is actor)
tool.connect(line, handle, handle.pos)
cinfo = view.canvas.get_connection(handle)
self.assertTrue(cinfo.item is line)
self.assertTrue(cinfo.connected is actor)
# Try to connect far away from any item will only do a full disconnect
self.assertEqual(
len(comment.subject.annotatedElement), 1, comment.subject.annotatedElement
)
self.assertTrue(actor.subject in comment.subject.annotatedElement)
sink = tool.glue(line, handle, (500, 500))
self.assertTrue(sink is None, sink)
tool.connect(line, handle, (500, 500))
cinfo = view.canvas.get_connection(handle)
self.assertTrue(cinfo is None)
def setUp(self):
Application.init()
element_factory = Application.get_service("element_factory")
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/issue_53.gaphor")
load(path, element_factory)
def setUp(self):
Application.init(services=self.services)
self.element_factory = Application.get_service('element_factory')
assert len(list(self.element_factory.select())) == 0, list(
self.element_factory.select())
self.diagram = self.element_factory.create(UML.Diagram)
assert len(list(self.element_factory.select())) == 1, list(
self.element_factory.select())
def setUp(self):
Application.init()
element_factory = Application.get_service("element_factory")
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution("gaphor")
path = os.path.join(dist.location, "test-diagrams/issue_53.gaphor")
load(path, element_factory)
def setUp(self):
Application.init(services=[
'adapter_loader', 'element_factory', 'main_window', 'ui_manager',
'properties_manager', 'action_manager', 'properties',
'element_dispatcher'
])
self.main_window = Application.get_service('main_window')
self.main_window.open()
def setUp(self):
Application.init(services=[
"element_factory",
"main_window",
"action_manager",
"properties",
"element_dispatcher",
])
main_window = Application.get_service("main_window")
main_window.open()
self.element_factory = Application.get_service("element_factory")
self.diagram = self.element_factory.create(UML.Diagram)
self.page = DiagramPage(self.diagram)
self.page.construct()
self.assertEqual(self.page.diagram, self.diagram)
self.assertEqual(self.page.view.canvas, self.diagram.canvas)
self.assertEqual(len(self.element_factory.lselect()), 1)
def setUp(self):
Application.init()
element_factory = Application.get_service('element_factory')
from gaphor.storage.storage import load
dist = pkg_resources.get_distribution('gaphor')
path = os.path.join(dist.location, 'tests/issue_53.gaphor')
load(path, element_factory)
def test_iconnect_2(self):
"""Test connect/disconnect on comment and actor using comment-line.
"""
element_factory = Application.get_service("element_factory")
diagram = element_factory.create(UML.Diagram)
self.component_registry.handle(DiagramShow(diagram))
comment = diagram.create(CommentItem,
subject=element_factory.create(UML.Comment))
actor = diagram.create(ActorItem,
subject=element_factory.create(UML.Actor))
line = diagram.create(CommentLineItem)
view = self.get_diagram_view(diagram)
assert view, "View should be available here"
tool = ConnectHandleTool(view)
# Connect one end to the Comment:
handle = line.handles()[0]
tool.grab_handle(line, handle)
comment_bb = view.get_item_bounding_box(comment)
handle.pos = (comment_bb.x1, comment_bb.y1)
sink = tool.glue(line, handle, handle.pos)
assert sink is not None
assert sink.item is comment
tool.connect(line, handle, handle.pos)
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo is not None, None)
self.assertTrue(cinfo.item is line)
self.assertTrue(cinfo.connected is comment)
# Connect the other end to the Actor:
handle = line.handles()[-1]
tool.grab_handle(line, handle)
actor_bb = view.get_item_bounding_box(actor)
handle.pos = actor_bb.x1, actor_bb.y1
sink = tool.glue(line, handle, handle.pos)
self.assertTrue(sink.item is actor)
tool.connect(line, handle, handle.pos)
cinfo = view.canvas.get_connection(handle)
self.assertTrue(cinfo.item is line)
self.assertTrue(cinfo.connected is actor)
# Try to connect far away from any item will only do a full disconnect
self.assertEqual(len(comment.subject.annotatedElement), 1,
comment.subject.annotatedElement)
self.assertTrue(actor.subject in comment.subject.annotatedElement)
sink = tool.glue(line, handle, (500, 500))
self.assertTrue(sink is None, sink)
tool.connect(line, handle, (500, 500))
cinfo = view.canvas.get_connection(handle)
self.assertTrue(cinfo is None)
def load_generator(filename, factory):
"""
Load a file and create a model if possible.
This function is a generator. It will yield values from 0 to 100 (%)
to indicate its progression.
"""
if isinstance(filename, io.IOBase):
log.info('Loading file from file descriptor')
else:
log.info('Loading file %s' % os.path.basename(filename))
try:
# Use the incremental parser and yield the percentage of the file.
loader = parser.GaphorLoader()
for percentage in parser.parse_generator(filename, loader):
pass
if percentage:
yield old_div(percentage, 2)
else:
yield percentage
elements = loader.elements
gaphor_version = loader.gaphor_version
#elements = parser.parse(filename)
#yield 100
except Exception as e:
log.error('File could no be parsed', exc_info=True)
raise
try:
component_registry = Application.get_service('component_registry')
except NotInitializedError:
component_registry = None
try:
factory.flush()
gc.collect()
log.info("Read %d elements from file" % len(elements))
if component_registry:
component_registry.register_subscription_adapter(
ElementChangedEventBlocker)
try:
for percentage in load_elements_generator(elements, factory,
gaphor_version):
if percentage:
yield old_div(percentage, 2) + 50
else:
yield percentage
except Exception as e:
raise
finally:
if component_registry:
component_registry.unregister_subscription_adapter(
ElementChangedEventBlocker)
gc.collect()
yield 100
except Exception as e:
log.info('file %s could not be loaded' % filename)
raise
def tearDown(self):
"""Finished with the test case. Unregister event handlers that
store transaction events."""
component_registry = Application.get_service('component_registry')
component_registry.unregister_handler(handle_begins, [TransactionBegin])
component_registry.unregister_handler(handle_commits, [TransactionCommit])
component_registry.unregister_handler(handle_rollback, [TransactionRollback])
def setUp(self):
Application.init(services=[
"event_manager",
"component_registry",
"element_factory",
"main_window",
"properties_manager",
"action_manager",
"properties",
"namespace",
"diagrams",
"toolbox",
])
self.component_registry = Application.get_service("component_registry")
self.event_manager = Application.get_service("event_manager")
self.main_window = Application.get_service("main_window")
self.main_window.open()
def setUp(self):
Application.init(services=[
"adapter_loader",
"element_factory",
"main_window",
"properties_manager",
"action_manager",
"properties",
"element_dispatcher",
])
self.main_window = Application.get_service("main_window")
self.main_window.init()
self.main_window.open()
self.element_factory = Application.get_service("element_factory")
self.diagram = self.element_factory.create(UML.Diagram)
self.comment = self.diagram.create(CommentItem,
subject=self.element_factory.create(
UML.Comment))
self.commentline = self.diagram.create(CommentLineItem)
def setUp(self):
Application.init(services=self.services)
self.element_factory = Application.get_service("element_factory")
assert len(list(self.element_factory.select())) == 0, list(
self.element_factory.select()
)
self.diagram = self.element_factory.create(UML.Diagram)
assert len(list(self.element_factory.select())) == 1, list(
self.element_factory.select()
)
def test_show_diagram(self):
main_w = MainWindow()
element_factory = Application.get_service('element_factory')
diagram = element_factory.create(UML.Diagram)
ui_manager = gtk.UIManager()
main_w.ui_manager = ui_manager
main_w.construct()
self.assertEqual(main_w.get_current_diagram(), None)
main_w.show_diagram(diagram)
def setUp(self):
Application.init(
services=[
"element_factory",
"main_window",
"properties_manager",
"action_manager",
"properties",
"element_dispatcher",
]
)
self.main_window = Application.get_service("main_window")
self.main_window.open()
self.element_factory = Application.get_service("element_factory")
self.diagram = self.element_factory.create(UML.Diagram)
self.comment = self.diagram.create(
CommentItem, subject=self.element_factory.create(UML.Comment)
)
self.commentline = self.diagram.create(CommentLineItem)
def setUp(self):
Application.init(
services=[
"element_factory",
"main_window",
"action_manager",
"properties",
"element_dispatcher",
]
)
main_window = Application.get_service("main_window")
main_window.open()
self.element_factory = Application.get_service("element_factory")
self.diagram = self.element_factory.create(UML.Diagram)
self.page = DiagramPage(self.diagram)
self.page.construct()
self.assertEqual(self.page.diagram, self.diagram)
self.assertEqual(self.page.view.canvas, self.diagram.canvas)
self.assertEqual(len(self.element_factory.lselect()), 1)
def setUp(self):
Application.init(services=[
"file_manager",
"element_factory",
"properties",
"main_window",
"action_manager",
])
self.recent_files_backup = Application.get_service("properties").get(
"recent-files")
def test_uml_associations(self):
from zope import component
from gaphor.UML.interfaces import IAssociationChangeEvent
from gaphor.UML.properties import association, derivedunion
from gaphor.UML import Element
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('derived_a', 0, 1, A.a1, A.a2)
A.derived_b = derivedunion('derived_b', 0, '*', A.b1, A.b2, A.b3)
events = []
@component.adapter(IAssociationChangeEvent)
def handler(event, events=events):
events.append(event)
compreg = Application.get_service('component_registry')
compreg.register_handler(handler)
try:
a = A()
undo_manager = UndoManager()
undo_manager.init(Application)
undo_manager.begin_transaction()
a.a1 = 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:
compreg.unregister_handler(handler)
undo_manager.shutdown()
def test_iconnect(self):
"""
Test basic glue functionality using CommentItem and CommentLine
items.
"""
element_factory = Application.get_service('element_factory')
diagram = element_factory.create(UML.Diagram)
comment = diagram.create(CommentItem,
subject=element_factory.create(UML.Comment))
#assert comment.height == 50
#assert comment.width == 100
actor = diagram.create(ActorItem,
subject=element_factory.create(UML.Actor))
actor.matrix.translate(200, 200)
diagram.canvas.update_matrix(actor)
line = diagram.create(CommentLineItem)
view = self.get_diagram_view(diagram)
assert view, 'View should be available here'
tool = ConnectHandleTool(view)
# select handle:
handle = line.handles()[-1]
tool._grabbed_item = line
tool._grabbed_handle = handle
# Should glue to (238, 248)
handle.pos = 245, 248
item = tool.glue(line, handle, (245, 248))
self.assertTrue(item is not None)
self.assertEquals((238, 248),
view.canvas.get_matrix_i2c(line).transform_point(
handle.x, handle.y))
handle.pos = 245, 248
tool.connect(line, handle, (245, 248))
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo.constraint is not None)
self.assertTrue(cinfo.connected is actor, cinfo.connected)
self.assertEquals(
(238, 248),
view.get_matrix_i2v(line).transform_point(handle.x, handle.y))
Connector(line, handle).disconnect()
#tool.disconnect(line, handle)
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo is None)
def testLoadAll(self):
from gaphor.application import Application
Application.init()
am = Application.get_service("action_manager")
ui = am.ui_manager.get_ui()
assert '<menuitem name="file-quit" action="file-quit"/>' in ui, ui
# From filemanager:
assert '<menuitem name="file-new" action="file-new"/>' in ui, ui
# From Undomanager
assert '<toolitem name="edit-undo" action="edit-undo"/>' in ui, ui
def test_uml_associations(self):
from gaphor.UML.event import AssociationChangeEvent
from gaphor.UML.properties import association, derivedunion
from gaphor.UML import Element
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("derived_a", 0, 1, A.a1, A.a2)
A.derived_b = derivedunion("derived_b", 0, "*", A.b1, A.b2, A.b3)
events = []
@event_handler(AssociationChangeEvent)
def handler(event, events=events):
events.append(event)
compreg = Application.get_service("component_registry")
compreg.register_handler(handler)
try:
a = A(factory=self.element_factory)
undo_manager = UndoManager()
undo_manager.init(Application)
undo_manager.begin_transaction()
a.a1 = A(factory=self.element_factory)
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:
compreg.unregister_handler(handler)
undo_manager.shutdown()
def test_recent_files(self):
fileman = Application.get_service('file_manager')
properties = Application.get_service('properties')
# ensure the recent_files list is empty:
properties.set('recent-files', [])
fileman.update_recent_files()
for i in range(0, 9):
a = fileman.action_group.get_action('file-recent-%d' % i)
assert a
assert a.get_property('visible') == False, '%s, %d' % (a.get_property('visible'), i)
fileman.filename = 'firstfile'
a = fileman.action_group.get_action('file-recent-%d' % 0)
assert a
assert a.get_property('visible') == True
assert a.props.label == '_1. firstfile', a.props.label
for i in range(1, 9):
a = fileman.action_group.get_action('file-recent-%d' % i)
assert a
assert a.get_property('visible') == False
def test_uml_associations(self):
from zope import component
from gaphor.UML.interfaces import IAssociationChangeEvent
from gaphor.UML.properties import association, derivedunion
from gaphor.UML import Element
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('derived_a', 0, 1, A.a1, A.a2)
A.derived_b = derivedunion('derived_b', 0, '*', A.b1, A.b2, A.b3)
events = []
@component.adapter(IAssociationChangeEvent)
def handler(event, events=events):
events.append(event)
compreg = Application.get_service('component_registry')
compreg.register_handler(handler)
try:
a = A()
undo_manager = UndoManager()
undo_manager.init(Application)
undo_manager.begin_transaction()
a.a1 = 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:
compreg.unregister_handler(handler)
undo_manager.shutdown()
def test(self):
factory = Application.get_service('element_factory')
ns = NamespaceModel(factory)
m = factory.create(UML.Package)
m.name = 'm'
assert ns._nodes.has_key(m)
assert ns.path_from_element(m) == (1,)
assert ns.element_from_path((1,)) is m
a = factory.create(UML.Package)
a.name = 'a'
assert a in ns._nodes
assert a in ns._nodes[None]
assert m in ns._nodes
assert ns.path_from_element(a) == (1,), ns.path_from_element(a)
assert ns.path_from_element(m) == (2,), ns.path_from_element(m)
a.package = m
assert a in ns._nodes
assert a not in ns._nodes[None]
assert a in ns._nodes[m]
assert m in ns._nodes
assert a.package is m
assert a in m.ownedMember
assert a.namespace is m
assert ns.path_from_element(a) == (1, 0), ns.path_from_element(a)
c = factory.create(UML.Class)
c.name = 'c'
assert c in ns._nodes
assert ns.path_from_element(c) == (1,), ns.path_from_element(c)
assert ns.path_from_element(m) == (2,), ns.path_from_element(m)
assert ns.path_from_element(a) == (2, 0), ns.path_from_element(a)
c.package = m
assert c in ns._nodes
assert c not in ns._nodes[None]
assert c in ns._nodes[m]
c.package = a
assert c in ns._nodes
assert c not in ns._nodes[None]
assert c not in ns._nodes[m]
assert c in ns._nodes[a]
c.unlink()
assert c not in ns._nodes
assert c not in ns._nodes[None]
assert c not in ns._nodes[m]
assert c not in ns._nodes[a]
def setUp(self):
Application.init(
services=[
"file_manager",
"element_factory",
"properties",
"main_window",
"action_manager",
]
)
self.recent_files_backup = Application.get_service("properties").get(
"recent-files"
)
def setUp(self):
Application.init(
services=[
"element_factory",
"main_window",
"properties_manager",
"action_manager",
"properties",
"element_dispatcher",
]
)
self.main_window = Application.get_service("main_window")
self.main_window.open()
def setUp(self):
super(ElementDispatcherAsServiceTestCase, self).setUp()
self.events = []
self.dispatcher = Application.get_service("element_dispatcher")
element_factory = self.element_factory
class A(Element):
def __init__(self):
super().__init__(factory=element_factory)
A.one = association("one", A, lower=0, upper=1, composite=True)
A.two = association("two", A, lower=0, upper=2, composite=True)
self.A = A
def test_recent_files(self):
fileman = Application.get_service("file_manager")
properties = Application.get_service("properties")
# ensure the recent_files list is empty:
properties.set("recent-files", [])
fileman.update_recent_files()
for i in range(0, 9):
a = fileman.action_group.get_action("file-recent-%d" % i)
assert a
assert a.get_property("visible") == False, "%s, %d" % (
a.get_property("visible"),
i,
)
fileman.filename = "firstfile"
a = fileman.action_group.get_action("file-recent-%d" % 0)
assert a
assert a.get_property("visible") == True
assert a.props.label == "_1. firstfile", a.props.label
for i in range(1, 9):
a = fileman.action_group.get_action("file-recent-%d" % i)
assert a
assert a.get_property("visible") == False
def setUp(self):
"""Initialize Gaphor services and register transaction event
handlers."""
Application.init(services=['component_registry'])
component_registry = Application.get_service('component_registry')
component_registry.register_handler(handle_begins, [TransactionBegin])
component_registry.register_handler(handle_commits, [TransactionCommit])
component_registry.register_handler(handle_rollback, [TransactionRollback])
del begins[:]
del commits[:]
del rollbacks[:]
def test_iconnect(self):
"""
Test basic glue functionality using CommentItem and CommentLine
items.
"""
element_factory = Application.get_service('element_factory')
diagram = element_factory.create(UML.Diagram)
comment = diagram.create(CommentItem, subject=element_factory.create(UML.Comment))
#assert comment.height == 50
#assert comment.width == 100
actor = diagram.create(ActorItem, subject=element_factory.create(UML.Actor))
actor.matrix.translate(200, 200)
diagram.canvas.update_matrix(actor)
line = diagram.create(CommentLineItem)
view = self.get_diagram_view(diagram)
assert view, 'View should be available here'
tool = ConnectHandleTool(view)
# select handle:
handle = line.handles()[-1]
tool._grabbed_item = line
tool._grabbed_handle = handle
# Should glue to (238, 248)
handle.pos = 245, 248
item = tool.glue(line, handle, (245, 248))
self.assertTrue(item is not None)
self.assertEquals((238, 248), view.canvas.get_matrix_i2c(line).transform_point(handle.x, handle.y))
handle.pos = 245, 248
tool.connect(line, handle, (245, 248))
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo.constraint is not None)
self.assertTrue(cinfo.connected is actor, cinfo.connected)
self.assertEquals((238, 248), view.get_matrix_i2v(line).transform_point(handle.x, handle.y))
Connector(line, handle).disconnect()
#tool.disconnect(line, handle)
cinfo = diagram.canvas.get_connection(handle)
self.assertTrue(cinfo is None)
def testPackageRemovalByRemovingTheDiagram(self):
element_factory = Application.get_service('element_factory')
diagram = element_factory.lselect(lambda e: e.isKindOf(UML.Diagram) and e.name == 'Stereotypes diagram')[0]
self.assertTrue(diagram)
diagram.unlink()
self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.Profile)))
classes = element_factory.lselect(lambda e: e.isKindOf(UML.Class))
self.assertEquals(1, len(classes))
# Check if the link is really removed:
self.assertFalse(classes[0].appliedStereotype)
self.assertFalse(element_factory.lselect(lambda e: e.isKindOf(UML.InstanceSpecification)))
self.assertEquals(2, len(element_factory.lselect(lambda e: e.isKindOf(UML.Diagram))))
