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_max(self):
from cocktail.schema import Collection, exceptions
self._test_validation(
Collection(max=3, required=False),
[None, [], ["a"], (1, 2), set([1, 2, 3])],
[["a", "b", "c", "d"], list(range(10))], exceptions.MaxItemsError)
def test_min(self):
from cocktail.schema import Collection, exceptions
self._test_validation(
Collection(min=3, required=False),
[None, [1, 2, 3], ["a", "b", "c", "d"],
list(range(50))], [[], ["a"], [1, 2]], exceptions.MinItemsError)
def test_items(self):
from cocktail.schema import Collection, Integer, exceptions
self._test_validation(
Collection(items=Integer(), required=False),
[None, [], [1], [1, 2],
set([1, 2, 3]),
tuple(range(10))], [["a", "b", "c"], [3.5, 2.7, 1.4]],
exceptions.TypeCheckError,
error_count=3)
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 get_schema(self):
from cocktail.schema import Schema, Reference, Collection
schema = Schema()
schema.add_member(Reference("parent", type=schema, bidirectional=True))
schema.add_member(
Collection("children",
items=Reference(type=schema),
bidirectional=True))
return schema
def test_new_related_collection_many_to_many(self):
from cocktail.schema import SchemaObject, Reference, Collection
class Foo(SchemaObject):
pass
backref = Collection()
class Bar(SchemaObject):
foo = Collection(items=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(isinstance(backref.items, Reference))
self.assertTrue(backref.items.type is Bar)
self.assertTrue(Bar.foo.related_end is backref)
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)
class Foo(PersistentObject):
bar = Collection(bidirectional=True)
class Foo(PersistentObject):
bar = Collection()
def selection(self):
return self.params.read(
Collection("selection", items = Reference(type = Item))
)
class Container(SchemaObject):
components = Collection(bidirectional=True, integral=True)
class Component(SchemaObject):
containers = Collection(bidirectional=True)
class TestObject(PersistentObject):
collection = Collection(cascade_delete=True)
class TestObject(PersistentObject):
collection = Collection()
class TestObject(PersistentObject):
collection = Collection(cascade_delete=True)
def _should_cascade_delete_member(self, member):
return False
class Bar(SchemaObject):
foos = Collection(bidirectional=True)
def test_collection_relation_constraints(self):
from cocktail.schema import Collection, Integer, exceptions, get
foreign_field = Integer("foo")
collection = Collection(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(collection, [[], [None], [{
"foo": 4
}, {
"foo": 6
}], [{
"foo": 4
}, {
"foo": 7
}]])
self._test_validation(
collection,
None,
[[{}], [{
"foo": None
}], [{
"foo": 6
}, {}]],
exceptions.RelationConstraintError,
error_count=2 # Note that x > None is always True
)
self._test_validation(
collection,
None, [[{
"foo": -6
}, {
"foo": 1
}, {
"foo": 3
}]],
exceptions.RelationConstraintError,
{"constraint": collection.relation_constraints[1]},
error_count=3)
self._test_validation(
collection,
None, [[{
"foo": 8
}, {
"foo": 12
}, {
"foo": 134
}]],
exceptions.RelationConstraintError,
{"constraint": collection.relation_constraints[2]},
error_count=3)
self._test_validation(
collection, None, [[{
"foo": 5
}]], exceptions.RelationConstraintError,
{"constraint": collection.relation_constraints[3]})
class Bar(SchemaObject):
foo = Collection(items=Reference(type=Foo), related_end=backref)
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):
bars = Collection(bidirectional=True)
class TestObject(PersistentObject):
parent = Reference(bidirectional=True)
collection = Collection(cascade_delete=True, bidirectional=True)