def test_commit_and_rollback_subtype(self):
""" Test commit and rollback of a subtype constraint. """
obj1 = ObjectType(name="O1")
obj2 = ObjectType(name="O2")
cons = Constraint.SubtypeConstraint(subtype=obj1, supertype=obj2)
self.assertEquals(obj1.covered_by, [])
self.assertEquals(obj1.direct_subtypes, [])
self.assertEquals(obj1.direct_supertypes, [])
self.assertEquals(obj2.covered_by, [])
self.assertEquals(obj2.direct_subtypes, [])
self.assertEquals(obj2.direct_supertypes, [])
cons.commit()
self.assertEquals(obj1.covered_by, [cons])
self.assertEquals(obj1.direct_subtypes, [])
self.assertEquals(obj1.direct_supertypes, [obj2])
self.assertEquals(obj2.covered_by, [cons])
self.assertEquals(obj2.direct_subtypes, [obj1])
self.assertEquals(obj2.direct_supertypes, [])
with self.assertRaises(NotImplementedError):
cons.rollback()
# The commented out code below was used before I decided to raise
# NotImplementedError for rollback. See the comments in rollback().
"""
def test_duplicate_role_name(self):
""" Test that a new name is generated for a role if the role name is
already present on the fact type. """
fact_type = FactType(name="Test")
fact_type.add_role(ObjectType(name="Person"), name="R1")
fact_type.add_role(ObjectType(name="Dog"), name="R1")
names = [role.name for role in fact_type.roles]
self.assertEquals(names, ["R1", "Dog"])
def test_display_nonempty(self):
""" Test display of non-empty set."""
_set = ModelElementSet()
_set.add(ObjectType(name="GHI"))
_set.add(ObjectType(name="XYZ"))
_set.add(ObjectType(name="ABC"))
_set.display()
output = sys.stdout.getvalue().strip()
self.assertEqual(output, "Model Elements:\n ABC\n GHI\n XYZ")
def test_commit_and_rollback_value(self):
""" Test commit and rollback of value constraints. """
d0 = Domain.IntegerDomain()
role = Role(name="R1")
obj = ObjectType(name="O1", data_type=d0)
d1 = Constraint.ValueDomain()
d1.add_range("Dog")
rvc = Constraint.ValueConstraint(name="RVC", covers=[role], domain=d1)
self.assertEquals(role.covered_by, [])
rvc.commit()
self.assertEquals(role.covered_by, [rvc])
rvc.rollback()
self.assertEquals(role.covered_by, [])
vc = Constraint.ValueConstraint(name="VTVC", covers=[obj], domain=d1)
self.assertEquals(obj.covered_by, [])
self.assertEquals(obj.domain, obj.data_type)
self.assertEquals(obj.domain, d0)
vc.commit()
self.assertEquals(obj.covered_by, [vc])
self.assertEquals(obj.domain, d1)
self.assertEquals(obj.data_type, d0)
vc.rollback()
self.assertEquals(obj.covered_by, [])
self.assertEquals(obj.domain, obj.data_type)
self.assertEquals(obj.domain, d0)
def test_domain(self):
""" Test object type domain under various name scenarios. """
actual = ObjectType().domain.draw(2)
expect = ['0', '1']
self.assertItemsEqual(actual, expect)
actual = ObjectType(name='').domain.draw(2)
expect = ['0', '1']
self.assertItemsEqual(actual, expect)
actual = ObjectType(name='Test').domain.draw(2)
expect = ['Test0', 'Test1']
self.assertItemsEqual(actual, expect)
actual = ObjectType(name='Test1').domain.draw(2)
expect = ['Test1_0', 'Test1_1']
self.assertItemsEqual(actual, expect)
def test_compatible_roles_via_subtype(self):
""" Test case where join is OK because one role player is a subtype of
the other role player. """
obj1 = ObjectType(name="A")
obj2 = ObjectType(name="B")
obj3 = ObjectType(name="C")
fact1 = FactType("AIsB")
fact1.add_role(obj1)
fact1.add_role(obj2)
fact2 = FactType("BIsC")
fact2.add_role(obj2)
fact2.add_role(obj3)
join1 = (fact1.roles[0], fact2.roles[0])
join2 = (fact2.roles[0], fact1.roles[0])
join_path = JoinPath()
# At this point there is no subtype relation from obj1 to obj2, so the
# join fails
with self.assertRaises(JoinPathException) as ex:
join_path.add_join(*join1)
msg = "join roles must be played by compatible object types"
self.assertEquals(ex.exception.message, msg)
with self.assertRaises(JoinPathException) as ex:
join_path.add_join(*join2)
msg = "join roles must be played by compatible object types"
self.assertEquals(ex.exception.message, msg)
# Create a subtype relation so the join succeeds.
cons = SubtypeConstraint(obj1, obj2)
cons.commit()
join_path.add_join(*join1)
self.assertEquals(join_path.joins, [join1])
# Reset the join path and try the join in the opposite direction
join_path = JoinPath()
join_path.add_join(*join2)
self.assertEquals(join_path.joins, [join2])
def test_rename(self):
""" Confirm items with same name added to set get renamed. """
_set = ModelElementSet()
_set.add(ObjectType(name="Item"))
_set.add(FactType(name="Item"))
_set.add(FactType(name="Item"))
self.assertEqual(_set.count(), 3)
self.assertIsInstance(_set.get("Item"), ObjectType)
self.assertIsInstance(_set.get("Item2"), FactType)
self.assertIsInstance(_set.get("Item3"), FactType)
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 setUp(self):
self.obj1 = ObjectType(name="A")
self.obj2 = ObjectType(name="B")
self.obj3 = ObjectType(name="C")
self.fact1 = FactType(name="AHasB")
self.fact1.add_role(self.obj1)
self.fact1.add_role(self.obj2)
self.fact2 = FactType(name="BHasC")
self.fact2.add_role(self.obj2)
self.fact2.add_role(self.obj3)
self.fact3 = FactType(name="ALikesA")
self.fact3.add_role(self.obj1)
self.fact3.add_role(self.obj1)
self.fact4 = FactType(name="ALikesB")
self.fact4.add_role(self.obj1)
self.fact4.add_role(self.obj2)
def test_display_nonempty(self):
""" Test Display of non-empty model. """
model = Model()
model.object_types.add(ObjectType(name="O1"))
model.fact_types.add(FactType(name="F1"))
model.fact_types.add(FactType(name="F2"))
model.constraints.add(Constraint(name="C1"))
model.display()
output = sys.stdout.getvalue().strip()
self.assertEqual(output, "Object Types:\n O1\nFact Types:\n F1\n F2\nConstraints:\n C1")
def test_commit_and_rollback_affect_on_role_unique(self):
""" Test affect of commit and rollback on role.unique """
fact = FactType("AHasB")
fact.add_role(ObjectType("A"))
fact.add_role(ObjectType("B"))
fact.commit()
role = fact.roles[0]
self.assertFalse(role.unique)
# Unique after covered by a simple IUC
uniq1 = Constraint.UniquenessConstraint(covers=[role])
uniq1.commit()
self.assertTrue(role.unique)
# No longer unique after rollback
uniq1.rollback()
self.assertFalse(role.unique)
# Not unique after covered by spanning IUC
uniq2 = Constraint.UniquenessConstraint(covers=[role, fact.roles[1]])
uniq2.commit()
self.assertFalse(role.unique)
# Unique again, covered by simple IUC
uniq1.commit()
self.assertTrue(role.unique)
# Cover by a second simple IUC
uniq3 = Constraint.UniquenessConstraint(covers=[role])
uniq3.commit()
# Still unique after rollback, because it's still covered by a simple IUC
uniq1.rollback()
self.assertTrue(role.unique)
# No longer unique: not covered by any simple IUCs.
uniq3.rollback()
self.assertFalse(role.unique)
def test_add_role(self):
""" Confirm we can add a role to the fact type. """
obj1 = ObjectType(name="Person")
obj2 = ObjectType(name="School")
fact_type = FactType(name="PersonAttendsSchoolWithPersonAndPerson")
role1 = fact_type.add_role(obj1)
role2 = fact_type.add_role(obj2)
role3 = fact_type.add_role(obj1)
role4 = fact_type.add_role(obj1)
self.assertEquals(fact_type.arity(), 4)
self.assertIs(role1.fact_type, fact_type)
self.assertIs(role1.player, obj1)
self.assertEquals(role1.name, "Person")
self.assertIs(role2.fact_type, fact_type)
self.assertIs(role2.player, obj2)
self.assertEquals(role2.name, "School")
self.assertIs(role3.fact_type, fact_type)
self.assertIs(role3.player, obj1)
self.assertEquals(role3.name, "Person2")
self.assertIs(role4.fact_type, fact_type)
self.assertIs(role4.player, obj1)
self.assertEquals(role4.name, "Person3")
self.assertItemsEqual(obj1.roles, [])
self.assertItemsEqual(obj2.roles, [])
fact_type.commit()
self.assertItemsEqual(obj1.roles, [role1, role3, role4])
self.assertItemsEqual(obj2.roles, [role2])
def test_add_remove_object_type(self):
""" Test adding and removing an object type from the model. """
model = Model()
obj1 = ObjectType(name="O1")
model.add(obj1)
self.assertEquals(model.object_types.count(), 1)
self.assertEquals(model.object_types.get("O1"), obj1)
with self.assertRaises(NotImplementedError):
model.remove(obj1)
# I decided for now to just raise a NotImplementedError for rollback,
# since I'm not sure what the right behavior should be.
"""
def test_add_remove_fact_type(self):
""" Test adding and removing a fact type from the model. """
model = Model()
fact = FactType(name="F1")
fact.add_role(player=ObjectType(name="O1"))
model.add(fact)
self.assertEquals(model.fact_types.count(), 1)
self.assertEquals(model.fact_types.get("F1"), fact)
with self.assertRaises(NotImplementedError):
model.remove(fact)
# I decided for now to just raise a NotImplementedError for rollback,
# since I'm not sure what the right behavior should be.
"""
def test_get_elements(self):
""" Test get() method. """
model = Model()
obj = ObjectType(name="O1")
cons = Constraint(name="O1")
fact = FactType(name="F1")
model.add(obj)
model.add(cons)
model.add(fact)
self.assertEquals(model.get("ObjectTypes.O1"), obj)
self.assertEquals(model.get("Constraints.O1"), cons)
self.assertEquals(model.get("FactTypes.F1"), fact)
self.assertEquals(model.get("ObjectTypes."), None)
self.assertEquals(model.get("F1"), None)
def test_add_remove_constraint_with_side_effects(self):
""" Test adding and removing a generic constraint from the model. """
model = Model()
obj1 = ObjectType(name="O1")
cons1 = Constraint(name="C1", covers=[obj1])
model.add(obj1)
model.add(cons1)
self.assertEquals(model.constraints.count(), 1)
self.assertEquals(model.constraints.get("C1"), cons1)
self.assertEquals(model.constraints.get("C1").covers[0], obj1)
self.assertEquals(model.object_types.get("O1").covered_by[0], cons1)
model.remove(cons1)
self.assertEquals(model.constraints.count(), 0)
self.assertEquals(model.constraints.get("C1"), None)
self.assertEquals(model.object_types.get("O1").covered_by, [])
def setUp(self):
self.object_type1 = ObjectType(name="Object Type 1")
self.fact_type1 = FactType(name="Fact Type 1")
self.constraint1 = Constraint(name="Constraint 1")
def test_rollback(self):
""" Test rollback of an ObjectType. """
with self.assertRaises(NotImplementedError):
ObjectType().rollback()
def test_add_object_type(self):
""" Test the addition of an object type to a constraint. """
covers = [ObjectType(uid="2", name="O1")]
cons = Constraint.Constraint(uid="1", name="C1", covers=covers)
self.assertEquals(cons.covers[0].name, "O1")
