def testListFamily(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.listFamily` method.
"""
class FamilyB(AbstractCompositeNode):
__family = "B"
class FamilyC(AbstractCompositeNode):
__family = "C"
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = FamilyB("MyNodeB", nodeA)
nodeC = FamilyC("MyNodeC", nodeA)
nodeD = FamilyB("MyNodeD", nodeC)
nodeE = FamilyB("MyNodeE", nodeD)
nodeF = FamilyC("MyNodeE", nodeE)
familyNodes = [nodeB, nodeD, nodeE]
foundNodes = nodeA.findFamily("B")
for node in familyNodes:
self.assertIn(node, foundNodes)
familyNodes = [nodeC, nodeF]
foundNodes = nodeA.findFamily("C")
for node in familyNodes:
self.assertIn(node, foundNodes)
self.assertEqual(nodeA.findFamily("C", node=nodeE).pop(), nodeF)
def testAbstractCompositeNodePickle(self):
"""
This method tests :class:`foundations.nodes.AbstractCompositeNode` class pickling.
:note: :data:`pickle.HIGHEST_PROTOCOL` must be used to pickle :class:`foundations.nodes.AbstractCompositeNode` class.
"""
nodeA = AbstractCompositeNode("MyNodeA",
attributeA=Attribute(value="A"),
attributeB=Attribute(value="1"))
nodeB = AbstractCompositeNode("MyNodeB",
nodeA,
attributeA=Attribute(value="B"),
attributeB=Attribute(value="2"))
nodeC = AbstractCompositeNode("MyNodeC",
nodeA,
attributeA=Attribute(value="C"),
attributeB=Attribute(value="3"))
nodeD = AbstractCompositeNode("MyNodeD",
nodeB,
attributeA=Attribute(value="D"),
attributeB=Attribute(value="4"))
data = pickle.dumps(nodeA, pickle.HIGHEST_PROTOCOL)
data = pickle.loads(data)
self.assertEqual(nodeA, data)
def __init__(self, name=None, parent=None, children=None, roles=None, flags=None, **kwargs):
"""
Initializes the class.
:param name: Node name.
:type name: unicode
:param parent: Node parent.
:type parent: AbstractNode or AbstractCompositeNode
:param children: Children.
:type children: list
:param roles: Roles.
:type roles: dict
:param flags: Flags. ( Qt.ItemFlag )
:param \*\*kwargs: Keywords arguments.
:type \*\*kwargs: \*\*
"""
LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))
AbstractCompositeNode.__init__(self, name, parent, children, **kwargs)
Mixin_GraphModelObject.__init__(self)
# --- Setting class attributes. ---
self.roles = roles or {Qt.DisplayRole : self.name, Qt.EditRole : self.name}
self.flags = flags or int(Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
def testIndexOf(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.indexOf` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
self.assertEqual(nodeA.indexOf(nodeB), 0)
def testListNode(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.listNode` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
self.assertIsInstance(nodeA.listNode(), unicode)
def testHasChildren(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.hasChildren` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
self.assertFalse(nodeA.hasChildren())
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
self.assertTrue(nodeA.hasChildren())
def testRemoveChild(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.removeChild` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
self.assertEqual(nodeA.removeChild(0), nodeB)
self.assertListEqual(nodeA.children, [])
self.assertEqual(nodeB.parent, None)
def testRow(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.row` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
nodeD = AbstractCompositeNode("MyNodeD", nodeA)
for i, node in enumerate((nodeB, nodeC, nodeD)):
self.assertEqual(node.row(), i)
def testAddChild(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.addChild` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB")
self.assertListEqual(nodeA.children, [])
self.assertTrue(nodeA.addChild(nodeB))
self.assertIn(nodeB, nodeA.children)
self.assertEqual(nodeB.parent, nodeA)
def __init__(self, name=None, parent=None, children=None, **kwargs):
"""
Initializes the class.
:param name: Node name.
:type name: unicode
:param parent: Node parent.
:type parent: AbstractCompositeNode
:param children: Children.
:type children: list
:param \*\*kwargs: Keywords arguments.
:type \*\*kwargs: \*\*
"""
LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))
AbstractCompositeNode.__init__(self, name, parent, children, **kwargs)
def __setattr__(self, attribute, value):
"""
Reimplements the :meth:`foundations.nodes.AbstractCompositeNode.__setattr__` method.
:param attribute.: Attribute.
:type attribute.: object
:param value.: Value.
:type value.: object
"""
currentValue = getattr(self, attribute, None)
AbstractCompositeNode.__setattr__(self, attribute, value)
if not attribute in ("_GraphModelNode__name",
"_GraphModelNode__roles",
"_GraphModelNode__flags"):
return
triggerModel = getattr(self, "_Mixin_GraphModelObject__triggerModel", False)
if triggerModel and value is not currentValue:
self.nodeChanged()
def testInsertChild(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.insertChild` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
nodeD = AbstractCompositeNode("MyNodeD")
self.assertTrue(nodeA.insertChild(nodeD, 1))
for i, node in enumerate((nodeB, nodeD, nodeC)):
self.assertEqual(nodeA.indexOf(node), i)
def testFindChildren(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.findChildren` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
nodeD = AbstractCompositeNode("MyNodeD", nodeC)
self.assertListEqual(nodeA.findChildren("MyNodeD"), [nodeD])
for node in nodeA.findChildren("mynode.*", re.IGNORECASE):
self.assertIn(node, (nodeB, nodeC, nodeD))
def testChildrenCount(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.childrenCount` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
self.assertEqual(nodeA.childrenCount(), 0)
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
self.assertEqual(nodeA.childrenCount(), 2)
def testChild(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.child` method.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
self.assertEqual(nodeA.child(0), nodeB)
self.assertEqual(nodeA.child(1), nodeC)
self.assertEqual(nodeA.child(2), None)
def testNodesWalker(self):
"""
Tests :func:`foundations.walkers.nodesWalker` definition.
"""
nodeA = AbstractCompositeNode("MyNodeA")
nodeB = AbstractCompositeNode("MyNodeB", nodeA)
nodeC = AbstractCompositeNode("MyNodeC", nodeA)
nodeD = AbstractCompositeNode("MyNodeD", nodeB)
nodeE = AbstractCompositeNode("MyNodeE", nodeB)
nodeF = AbstractCompositeNode("MyNodeF", nodeD)
nodeG = AbstractCompositeNode("MyNodeG", nodeF)
nodeH = AbstractCompositeNode("MyNodeH", nodeG)
values = [nodeB, nodeC, nodeD, nodeE, nodeF, nodeG, nodeH]
for node in values:
self.assertIn(node, list(foundations.walkers.nodesWalker(nodeA)))
values = [nodeG, nodeF, nodeD, nodeB, nodeA]
self.assertEquals(
list(foundations.walkers.nodesWalker(nodeH, ascendants=True)),
values)
def testSortChildrenNode(self):
"""
Tests :meth:`foundations.nodes.AbstractCompositeNode.sortChildren` method.
"""
nodeA = AbstractCompositeNode("MyNodeA", attributeA=Attribute(value="A"), attributeB=Attribute(value="1"))
nodeC = AbstractCompositeNode("MyNodeC", nodeA, attributeA=Attribute(value="C"), attributeB=Attribute(value="3"))
nodeB = AbstractCompositeNode("MyNodeB", nodeA, attributeA=Attribute(value="B"), attributeB=Attribute(value="2"))
nodeG = AbstractCompositeNode("MyNodeG", nodeB, attributeA=Attribute(value="G"))
nodeE = AbstractCompositeNode("MyNodeE", nodeB, attributeA=Attribute(value="E"), attributeB=Attribute(value="5"))
nodeF = AbstractCompositeNode("MyNodeF", nodeB, attributeA=Attribute(value="F"), attributeB=Attribute(value="6"))
nodeD = AbstractCompositeNode("MyNodeD", nodeB, attributeA=Attribute(value="D"), attributeB=Attribute(value="4"))
self.assertTrue(nodeA.sortChildren())
self.assertEqual(nodeA.children[0], nodeB)
self.assertEqual(nodeA.children[1], nodeC)
self.assertEqual(nodeA.children[0].children[0], nodeD)
self.assertEqual(nodeA.children[0].children[1], nodeE)
self.assertEqual(nodeA.children[0].children[2], nodeF)
self.assertTrue(nodeA.sortChildren(reverseOrder=True))
self.assertEqual(nodeA.children[0], nodeC)
self.assertEqual(nodeA.children[1], nodeB)
self.assertEqual(nodeA.children[1].children[0], nodeG)
self.assertEqual(nodeA.children[1].children[1], nodeF)
self.assertEqual(nodeA.children[1].children[2], nodeE)
self.assertEqual(nodeA.children[1].children[3], nodeD)
self.assertTrue(nodeA.sortChildren(attribute="attributeA"))
self.assertEqual(nodeA.children[0], nodeB)
self.assertEqual(nodeA.children[1], nodeC)
self.assertEqual(nodeA.children[0].children[0], nodeD)
self.assertEqual(nodeA.children[0].children[1], nodeE)
self.assertEqual(nodeA.children[0].children[2], nodeF)
self.assertTrue(nodeA.sortChildren(attribute="attributeA", reverseOrder=True))
self.assertEqual(nodeA.children[0], nodeC)
self.assertEqual(nodeA.children[1], nodeB)
self.assertEqual(nodeA.children[1].children[0], nodeG)
self.assertEqual(nodeA.children[1].children[1], nodeF)
self.assertEqual(nodeA.children[1].children[2], nodeE)
self.assertEqual(nodeA.children[1].children[3], nodeD)
self.assertTrue(nodeA.sortChildren(attribute="attributeB"))
self.assertEqual(nodeA.children[0], nodeB)
self.assertEqual(nodeA.children[1], nodeC)
self.assertEqual(nodeA.children[0].children[0], nodeD)
self.assertEqual(nodeA.children[0].children[1], nodeE)
self.assertEqual(nodeA.children[0].children[2], nodeF)
self.assertEqual(nodeA.children[0].children[3], nodeG)
self.assertTrue(nodeA.sortChildren(attribute="attributeB", reverseOrder=True))
self.assertEqual(nodeA.children[0], nodeC)
self.assertEqual(nodeA.children[1], nodeB)
self.assertEqual(nodeA.children[1].children[0], nodeF)
self.assertEqual(nodeA.children[1].children[1], nodeE)
self.assertEqual(nodeA.children[1].children[2], nodeD)
self.assertEqual(nodeA.children[1].children[3], nodeG)
