def test_mandatory_is_simple(self):
""" Test simple property on MandatoryConstraint. """
role1 = Role(uid="R1", name="R1")
role2 = Role(uid="R2", name="R2")
cons1 = Constraint.MandatoryConstraint(uid="C1",
name="C1",
covers=[role1])
cons2 = Constraint.MandatoryConstraint(uid="C2",
name="C2",
covers=[role1, role2])
self.assertTrue(cons1.simple)
self.assertFalse(cons2.simple)
def test_commit_rollback_ior(self):
""" Test commit and rollback of inclusive-or constraint. """
role1 = Role(name="R1")
role2 = Role(name="R2")
cons = Constraint.MandatoryConstraint(name="M1", covers=[role1, role2])
self.assertFalse(cons.simple)
self.assertEquals(role1.covered_by, [])
self.assertEquals(role2.covered_by, [])
self.assertFalse(role1.mandatory)
self.assertFalse(role2.mandatory)
cons.commit()
self.assertEquals(role1.covered_by, [cons])
self.assertEquals(role2.covered_by, [cons])
self.assertFalse(role1.mandatory) # False because cons is not simple
self.assertFalse(role2.mandatory) # False because cons is not simple
cons.rollback()
self.assertEquals(role1.covered_by, [])
self.assertEquals(role2.covered_by, [])
self.assertFalse(role1.mandatory)
self.assertFalse(role2.mandatory)
def test_commit_rollback_mandatory(self):
""" Test commit and rollback of mandatory constraint. """
role = Role(name="R1")
cons = Constraint.MandatoryConstraint(name="M1", covers=[role])
self.assertEquals(role.covered_by, [])
self.assertFalse(role.mandatory)
cons.commit()
self.assertEquals(role.covered_by, [cons])
self.assertTrue(role.mandatory)
cons.rollback()
self.assertEquals(role.covered_by, [])
self.assertFalse(role.mandatory)
def test_commit_and_rollback(self):
""" Test committing and rolling back constraints on a model. """
model = Model()
obj1 = ObjectType(name="O1")
obj2 = ObjectType(name="O2")
fact = FactType(name="F1")
role1 = fact.add_role(player=obj1, name="R1")
role2 = fact.add_role(player=obj2, name="R2")
cons1 = Constraint.MandatoryConstraint(name="M1", covers=[role1])
cons2 = Constraint.UniquenessConstraint(name="U1",
covers=[role1, role2])
cons3 = Constraint.ValueConstraint(name="V1", covers=[obj1])
for element in [obj1, obj2, fact, cons1, cons2, cons3]:
model.add(element)
self.assertEquals(model.constraints.get("M1").covers, [role1])
self.assertEquals(model.constraints.get("U1").covers, [role1, role2])
self.assertEquals(model.constraints.get("V1").covers, [obj1])
self.assertEquals(role1.covered_by, [cons1, cons2])
self.assertEquals(role2.covered_by, [cons2])
self.assertEquals(obj1.covered_by, [cons3])
model.remove(cons2)
model.remove(cons3)
self.assertEquals(model.constraints.get("M1"), cons1)
self.assertEquals(model.constraints.get("U1"), None)
self.assertEquals(model.constraints.get("V1"), None)
self.assertEquals(role1.covered_by, [cons1])
self.assertEquals(role2.covered_by, [])
self.assertEquals(obj1.covered_by, [])
# Test that additional rollback has no effect
model.remove(cons3)
self.assertEquals(model.constraints.get("M1"), cons1)
self.assertEquals(model.constraints.get("V1"), None)
self.assertEquals(obj1.covered_by, [])
def _load_mandatory_constraint(self, xml_node):
""" Load mandatory constraint. """
attribs, name = get_basic_attribs(xml_node)
implied = (xml_node.get("IsImplied") == "true")
covers = self._load_role_sequence(xml_node,
"Mandatory constraint " + name)
# Lambda function to decide if constraint covers a subtype
subtype = lambda x: x and isinstance(x[0], Constraint.SubtypeConstraint
)
if implied:
return None
elif subtype(covers):
if len(covers) > 1: # If len == 1 its on the implicit subtype fact
self.omissions.append("Subtype inclusive-or constraint " +
name)
return None
else:
return Constraint.MandatoryConstraint(covers=covers, **attribs)