def test_bidirectional_assignment(self): from cocktail.schema import Collection, Reference from cocktail.persistence import ( PersistentObject, PersistentRelationOrderedSet ) class Foo(PersistentObject): bar = Collection(bidirectional = True) class Bar(PersistentObject): foo = Reference(bidirectional = True) Foo.bar.items = Reference(type = Bar) Bar.foo.type = Foo foo = Foo() bar = foo.bar value = [Bar(), Bar()] foo.bar = value self.assertTrue(foo.bar is bar) self.assertTrue(isinstance(foo.bar, PersistentRelationOrderedSet)) self.assertTrue(foo.bar.owner is foo) self.assertTrue(foo.bar.member is Foo.bar) self.assertEqual(list(foo.bar), value)
def test_no_match(self): from cocktail.schema import Schema, Reference from cocktail.schema.exceptions import SchemaIntegrityError a = Schema("a") b = Schema("b") a.add_member(Reference("rel_b", type=b, bidirectional=True)) b.add_member(Reference("rel_a", type=a)) def resolve_relation(): print(a["rel_b"].related_end) self.assertRaises(SchemaIntegrityError, resolve_relation) self.assertTrue(b["rel_a"].related_end is None)
def test_match_many_to_many(self): from cocktail.schema import Schema, Reference, Collection from cocktail.schema.exceptions import SchemaIntegrityError a = Schema("a") b = Schema("b") a.add_member( Collection("rel_b", items=Reference(type=b), bidirectional=True)) b.add_member( Collection("rel_a", items=Reference(type=a), bidirectional=True)) self.assertTrue(a["rel_b"].related_end is b["rel_a"]) self.assertTrue(a["rel_b"].related_type is b) self.assertTrue(b["rel_a"].related_end is a["rel_b"]) self.assertTrue(b["rel_a"].related_type is a)
def test_many_to_many(self): from cocktail.schema import SchemaObject, Reference, Collection from cocktail.schema.exceptions import SchemaIntegrityError class Container(SchemaObject): components = Collection(bidirectional=True, integral=True) class Component(SchemaObject): containers = Collection(bidirectional=True) Container.components.items = Reference(type=Component) Component.containers.items = Reference(type=Container) # 'integral' can't be set on an n:m relation def resolve_relation(): Container.components.related_end self.assertRaises(SchemaIntegrityError, resolve_relation)
class Document(PersistentObject): parent = Reference( bidirectional = True, related_key = "children" ) children = Collection( bidirectional = True, related_key = "parent" ) extension = Reference( bidirectional = True, related_key = "extended" ) extended = Reference( bidirectional = True, related_key = "extension" ) improvement = Reference() related_documents = Collection()
def relation_selection(self): member = self.relation_member value = get_parameter( Collection( name = "relation_selection-" + member.name, items = Reference(type = member.related_type) ) ) if not value: return [] else: enum = frozenset(self.stack_node.form_data.get(member.name)) return [item for item in value if item in enum]
def setUp(self): TempStorageMixin.setUp(self) from cocktail.schema import Reference, Collection from cocktail.persistence import PersistentObject, datastore datastore.root.clear() class Document(PersistentObject): parent = Reference( bidirectional = True, related_key = "children" ) children = Collection( bidirectional = True, related_key = "parent" ) extension = Reference( bidirectional = True, related_key = "extended" ) extended = Reference( bidirectional = True, related_key = "extension" ) improvement = Reference() related_documents = Collection() Document.extension.type = Document Document.extended.type = Document Document.parent.type = Document Document.children.items = Reference(type = Document) Document.improvement.type = Document Document.related_documents.items = Reference(type = Document) self.Document = Document
def get_entities(self): from cocktail.schema import SchemaObject, Reference, Collection class Foo(SchemaObject): bar = Reference(bidirectional=True) class Bar(SchemaObject): foos = Collection(bidirectional=True) Foo.bar.type = Bar Bar.foos.items = Reference(type=Foo) return Foo, Bar
def test_one_to_many(self): from cocktail.schema import SchemaObject, Reference, Collection from cocktail.schema.exceptions import SchemaIntegrityError class Foo(SchemaObject): pass class Bar(SchemaObject): pass Foo.add_member(Reference("bar", type=Bar, bidirectional=True)) Bar.add_member( Collection("foos", items=Reference(type=Foo), bidirectional=True)) foo = Foo() bar = Bar() foo.bidirectional = False foo.bar = bar self.assertTrue(foo.bar is bar) self.assertFalse(bar.foos) bar.foos = [foo] self.assertEqual(bar.foos, [foo]) self.assertTrue(foo.bar is bar) foo.bidirectional = True foo.bar = None self.assertTrue(foo.bar is None) self.assertFalse(bar.foos) bar.bidirectional = False bar.foos = [foo] self.assertEqual(bar.foos, [foo]) self.assertTrue(foo.bar is None)
def test_reference_relation_constraints(self): from cocktail.schema import Reference, Integer, exceptions, get foreign_field = Integer("foo") ref = Reference(relation_constraints=[ foreign_field.not_equal(None), foreign_field.greater(3), foreign_field.lower(8), lambda owner, related: get(related, "foo", None) is None or get( related, "foo", None) % 5 != 0 ]) self._test_validation(ref, [None, {"foo": 4}, {"foo": 6}, {"foo": 7}]) self._test_validation( ref, None, [{}, { "foo": None }], exceptions.RelationConstraintError, error_count=2 # Note that x > None is always True ) self._test_validation(ref, None, [{ "foo": -6 }, { "foo": 1 }, { "foo": 3 }], exceptions.RelationConstraintError, {"constraint": ref.relation_constraints[1]}) self._test_validation(ref, None, [{ "foo": 8 }, { "foo": 12 }, { "foo": 134 }], exceptions.RelationConstraintError, {"constraint": ref.relation_constraints[2]}) self._test_validation(ref, None, [{ "foo": 5 }], exceptions.RelationConstraintError, {"constraint": ref.relation_constraints[3]})
def test_new_related_end(self): from cocktail.schema import SchemaObject, Reference class Foo(SchemaObject): pass backref = Reference() class Bar(SchemaObject): foo = Reference(type=Foo, related_end=backref) self.assertTrue(backref.schema is Foo) self.assertTrue(backref.name) self.assertTrue(getattr(Foo, backref.name) is backref) self.assertTrue(Bar.foo.bidirectional) self.assertTrue(backref.bidirectional) self.assertTrue(Bar.foo.related_end is backref)
def setUp(self): TempStorageMixin.setUp(self) from cocktail.schema import String, Reference, Collection from cocktail.persistence import PersistentObject class TestObject(PersistentObject): test_field = String( unique = True, indexed = True ) parent = Reference(bidirectional = True) children = Collection(bidirectional = True) TestObject.parent.type = TestObject TestObject.children.items = Reference(type = TestObject) self.test_type = TestObject
def test_class_family(self): from cocktail.schema import Reference class Foo(object): pass class Bar(Foo): pass class Spam(object): pass ref = Reference(class_family=Foo) assert ref.validate(None) assert ref.validate(Foo) assert ref.validate(Bar) assert not ref.validate(Spam)
def test_bidirectional_collection(self): from cocktail.schema import Collection, Reference from cocktail.persistence import PersistentObject class TestObject(PersistentObject): parent = Reference(bidirectional=True) collection = Collection(cascade_delete=True, bidirectional=True) TestObject.parent.type = TestObject TestObject.collection.items = Reference(type=TestObject) a = TestObject(collection=[TestObject(), TestObject()]) a.insert() a.delete() assert not TestObject.index
def test_bidirectional_default(self): from cocktail.schema import Collection, Reference from cocktail.persistence import (PersistentObject, PersistentRelationOrderedSet) class Foo(PersistentObject): bar = Collection(bidirectional=True) class Bar(PersistentObject): foo = Reference(bidirectional=True) Foo.bar.items = Reference(type=Bar) Bar.type = Foo foo = Foo() self.assertTrue(isinstance(foo.bar, PersistentRelationOrderedSet)) self.assertTrue(foo.bar.owner is foo) self.assertTrue(foo.bar.member is Foo.bar)
def test_default(self): from cocktail.schema import SchemaObject, Reference, Collection class Foo(SchemaObject): bars = Collection(bidirectional=True) class Bar(SchemaObject): foo = Reference(type=Foo, bidirectional=True) Foo.bars.items = Reference(type=Bar) default_foo = Foo() Bar.foo.default = default_foo a = Bar() b = Bar() assert a.foo is default_foo assert b.foo is default_foo assert len(default_foo.bars) == 2 assert set(default_foo.bars) == set([a, b])
class Bar(SchemaObject): foo = Collection(items=Reference(type=Foo), related_end=backref)
class Bar(PersistentObject): foo = Reference(bidirectional=True)
class TestObject(PersistentObject): ref = Reference(cascade_delete=True) def _should_cascade_delete_member(self, member): return True
def selection(self): return self.params.read( Collection("selection", items = Reference(type = Item)) )
def root(self): return self.params.read(Reference("root", type = Item))
class TestObject(PersistentObject): test_field = String(unique=True, indexed=True) test_ref = Reference() test_collection = Collection() test_translated_field = String(indexed=True, translated=True)
class Foo(SchemaObject): bar = Reference(bidirectional=True)
class Component(SchemaObject): container = Reference(type=Container, bidirectional=True, integral=True)
class Bar(SchemaObject): foo = Reference(bidirectional=True)
def test_default(self): from cocktail.schema import Reference self.assertFalse(Reference().integral)
class Bar(SchemaObject): foo = Reference(type=Foo)
class Bar(SchemaObject): foo = Reference(type=Foo, bidirectional=True)
class TestObject(PersistentObject): ref = Reference(cascade_delete=True)
class Bar(SchemaObject): foo = Reference(type=Foo, related_end=backref)