@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
pass
- class Child(_base.BasicEntity):
+ class Child(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
pass
- class Child(_base.BasicEntity):
+ class Child(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
def __init__(self, name):
self.name = name
# nonuselist -> uselist
singular_keywords = association_proxy('singular', 'keywords')
- class Keyword(_base.ComparableEntity):
+ class Keyword(cls.Comparable):
def __init__(self, keyword):
self.keyword = keyword
# nonuselist -> nonuselist
user = association_proxy('user_keyword', 'user')
- class UserKeyword(_base.ComparableEntity):
+ class UserKeyword(cls.Comparable):
def __init__(self, user=None, keyword=None):
self.user = user
self.keyword = keyword
- class Singular(_base.ComparableEntity):
+ class Singular(cls.Comparable):
def __init__(self, value=None):
self.value = value
from test.lib.entities import BasicEntity, ComparableEntity
from test.engine._base import TablesTest
-Entity = BasicEntity
-
class _ORMTest(object):
__requires__ = ('subqueries',)
def teardown_class(cls):
sa.orm.session.Session.close_all()
sa.orm.clear_mappers()
- # TODO: ensure mapper registry is empty
- # TODO: ensure instrumentation registry is empty
class ORMTest(_ORMTest, testing.TestBase):
pass
cls.classes = adict()
cls._setup_once_tables()
-
cls._setup_once_classes()
-
cls._setup_once_mappers()
-
cls._setup_once_inserts()
+ @classmethod
+ def teardown_class(cls):
+ cls.classes.clear()
+ _ORMTest.teardown_class()
+ cls._teardown_once_metadata_bind()
+
+ def setup(self):
+ self._setup_each_tables()
+ self._setup_each_mappers()
+ self._setup_each_inserts()
+
+ def teardown(self):
+ sa.orm.session.Session.close_all()
+ self._teardown_each_mappers()
+ self._teardown_each_tables()
+ self._teardown_each_bind()
+
@classmethod
def _setup_once_classes(cls):
if cls.run_setup_classes == 'once':
- baseline = subclasses(BasicEntity)
- cls.setup_classes()
- cls._register_new_class_artifacts(baseline)
+ cls._with_register_classes(cls.setup_classes)
@classmethod
def _setup_once_mappers(cls):
if cls.run_setup_mappers == 'once':
- baseline = subclasses(BasicEntity)
- cls.setup_mappers()
- cls._register_new_class_artifacts(baseline)
-
- def _setup_each_classes(self):
- if self.run_setup_classes == 'each':
- self.classes.clear()
- baseline = subclasses(BasicEntity)
- self.setup_classes()
- self._register_new_class_artifacts(baseline)
+ cls._with_register_classes(cls.setup_mappers)
def _setup_each_mappers(self):
if self.run_setup_mappers == 'each':
- baseline = subclasses(BasicEntity)
- self.setup_mappers()
- self._register_new_class_artifacts(baseline)
+ self._with_register_classes(self.setup_mappers)
+
+ @classmethod
+ def _with_register_classes(cls, fn):
+ """Run a setup method, framing the operation with a Base class
+ that will catch new subclasses to be established within
+ the "classes" registry.
+
+ """
+ class Base(object):
+ pass
+ class Basic(BasicEntity, Base):
+ pass
+ class Comparable(ComparableEntity, Base):
+ pass
+ cls.Basic = Basic
+ cls.Comparable = Comparable
+ fn()
+ for class_ in subclasses(Base):
+ cls.classes[class_.__name__] = class_
def _teardown_each_mappers(self):
# some tests create mappers in the test bodies
# clear mappers in any case
if self.run_setup_mappers != 'once':
sa.orm.clear_mappers()
-
- def setup(self):
- self._setup_each_tables()
- self._setup_each_classes()
-
- self._setup_each_mappers()
- self._setup_each_inserts()
-
- def teardown(self):
- sa.orm.session.Session.close_all()
- self._teardown_each_mappers()
- self._teardown_each_tables()
- self._teardown_each_bind()
-
- @classmethod
- def teardown_class(cls):
- for cl in cls.classes.values():
- cls.unregister_class(cl)
- _ORMTest.teardown_class()
- cls._teardown_once_metadata_bind()
+ if self.run_setup_classes == 'each':
+ cls.classes.clear()
@classmethod
def setup_classes(cls):
def setup_mappers(cls):
pass
- @classmethod
- def _register_new_class_artifacts(cls, baseline):
- for class_ in subclasses(BasicEntity) - baseline:
- cls.register_class(class_)
-
- @classmethod
- def register_class(cls, class_):
- name = class_.__name__
- if name[0].isupper:
- setattr(cls, name, class_)
- cls.classes[name] = class_
-
- @classmethod
- def unregister_class(cls, class_):
- name = class_.__name__
- if name[0].isupper:
- delattr(cls, name)
- del cls.classes[name]
-
@classmethod
def _load_fixtures(cls):
+ """Insert rows as represented by the fixtures() method."""
+
headers, rows = {}, {}
for table, data in cls.fixtures().iteritems():
if isinstance(table, basestring):
@classmethod
def setup_classes(cls):
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class User(Base):
cls.tables.table_c,
cls.tables.table_a)
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
class B(A):
pass
@classmethod
def setup_classes(cls):
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
class Bar(Foo):
@classmethod
def setup_classes(cls):
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
class B(A):
pass
@classmethod
def setup_classes(cls):
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
class B(A):
class C(A):
pass
- class Dest(_base.ComparableEntity):
+ class Dest(cls.Comparable):
pass
def test_noninherited_warning(self):
@classmethod
def setup_classes(cls):
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class Sub(Base):
pass
- class Related(_base.ComparableEntity):
+ class Related(cls.Comparable):
pass
cls.tables.engineers,
cls.tables.engineers_to_org)
- class Organization(_base.ComparableEntity):
+ class Organization(cls.Comparable):
pass
mapper(Organization, organizations, properties={
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
pass
class Child1(Parent):
pass
@classmethod
def setup_classes(cls):
- class Parent(_base.ComparableEntity):
+ class Parent(cls.Comparable):
pass
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class Sub(Base):
pass
- class Related(_base.ComparableEntity):
+ class Related(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Parent(_base.ComparableEntity):
+ class Parent(cls.Comparable):
pass
class Subparent(Parent):
pass
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class Sub(Base):
from test.lib import testing
from test.orm import _fixtures
-from test.orm._base import MappedTest, ComparableEntity
+from test.orm import _base
from test.lib.schema import Table, Column
-class SingleInheritanceTest(testing.AssertsCompiledSQL, MappedTest):
+class SingleInheritanceTest(testing.AssertsCompiledSQL, _base.MappedTest):
@classmethod
def define_tables(cls, metadata):
Table('employees', metadata,
@classmethod
def setup_classes(cls):
global Employee, Manager, Engineer, JuniorEngineer
- class Employee(ComparableEntity):
+ class Employee(cls.Comparable):
pass
class Manager(Employee):
pass
self.tables.reports,
self.classes.Engineer)
- class Report(ComparableEntity): pass
+ class Report(_base.ComparableEntity):
+ pass
mapper(Report, reports, properties={
'employee': relationship(Employee, backref='reports')})
self.tables.reports,
self.classes.Engineer)
- class Report(ComparableEntity): pass
+ class Report(_base.ComparableEntity):
+ pass
mapper(Report, reports, properties={
'employee': relationship(Employee, backref='reports')})
assert len(rq.join(Report.employee.of_type(Manager)).all()) == 1
assert len(rq.join(Report.employee.of_type(Engineer)).all()) == 0
-class RelationshipFromSingleTest(testing.AssertsCompiledSQL, MappedTest):
+class RelationshipFromSingleTest(testing.AssertsCompiledSQL, _base.MappedTest):
@classmethod
def define_tables(cls, metadata):
Table('employee', metadata,
@classmethod
def setup_classes(cls):
- class Employee(ComparableEntity):
+ class Employee(cls.Comparable):
pass
class Manager(Employee):
pass
- class Stuff(ComparableEntity):
+ class Stuff(cls.Comparable):
pass
def test_subquery_load(self):
use_default_dialect=True
)
-class RelationshipToSingleTest(MappedTest):
+class RelationshipToSingleTest(_base.MappedTest):
@classmethod
def define_tables(cls, metadata):
Table('employees', metadata,
@classmethod
def setup_classes(cls):
- class Company(ComparableEntity):
+ class Company(cls.Comparable):
pass
- class Employee(ComparableEntity):
+ class Employee(cls.Comparable):
pass
class Manager(Employee):
pass
)
go()
-class SingleOnJoinedTest(MappedTest):
+class SingleOnJoinedTest(_base.MappedTest):
@classmethod
def define_tables(cls, metadata):
global persons_table, employees_table
)
def test_single_on_joined(self):
- class Person(ComparableEntity):
+ class Person(_base.ComparableEntity):
pass
class Employee(Person):
pass
@classmethod
def setup_classes(cls):
- class Item(_base.BasicEntity):
+ class Item(cls.Basic):
def __init__(self, name):
self.name = name
def __repr__(self):
return "Item id=%d name=%s keywordassoc=%r" % (
self.item_id, self.name, self.keywords)
- class Keyword(_base.BasicEntity):
+ class Keyword(cls.Basic):
def __init__(self, name):
self.name = name
def __repr__(self):
return "Keyword id=%d name=%s" % (self.keyword_id, self.name)
- class KeywordAssociation(_base.BasicEntity):
+ class KeywordAssociation(cls.Basic):
def __init__(self, keyword, data):
self.keyword = keyword
self.data = data
@classmethod
def setup_classes(cls):
- class Owner(_base.BasicEntity):
+ class Owner(cls.Basic):
pass
- class Category(_base.BasicEntity):
+ class Category(cls.Basic):
pass
- class Thing(_base.BasicEntity):
+ class Thing(cls.Basic):
pass
- class Option(_base.BasicEntity):
+ class Option(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Left(_base.BasicEntity):
+ class Left(cls.Basic):
def __init__(self, data):
self.data = data
- class Middle(_base.BasicEntity):
+ class Middle(cls.Basic):
def __init__(self, data):
self.data = data
- class Right(_base.BasicEntity):
+ class Right(cls.Basic):
def __init__(self, data):
self.data = data
@classmethod
def setup_classes(cls):
- class Data(_base.BasicEntity):
+ class Data(cls.Basic):
pass
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
- class Stat(_base.BasicEntity):
+ class Stat(cls.Basic):
pass
@testing.fails_on('maxdb', 'FIXME: unknown')
@classmethod
def setup_classes(cls):
- class Department(_base.BasicEntity):
+ class Department(cls.Basic):
pass
- class Employee(_base.BasicEntity):
+ class Employee(cls.Basic):
pass
@testing.fails_on('maxdb', 'FIXME: unknown')
@classmethod
def setup_classes(cls):
- class Base(_base.BasicEntity):
+ class Base(cls.Basic):
def __init__(self, uid, x):
self.uid = uid
self.x = x
self.x = x
self.z = z
- class Comment(_base.BasicEntity):
+ class Comment(cls.Basic):
def __init__(self, uid, comment):
self.uid = uid
self.comment = comment
@classmethod
def setup_classes(cls):
- class Part(_base.BasicEntity):
+ class Part(cls.Basic):
pass
- class Design(_base.BasicEntity):
+ class Design(cls.Basic):
pass
- class DesignType(_base.BasicEntity):
+ class DesignType(cls.Basic):
pass
- class InheritedPart(_base.BasicEntity):
+ class InheritedPart(cls.Basic):
pass
def test_one(self):
@classmethod
def setup_classes(cls):
- class Company(_base.ComparableEntity):
+ class Company(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
- class Phone(_base.ComparableEntity):
+ class Phone(cls.Comparable):
pass
- class Invoice(_base.ComparableEntity):
+ class Invoice(cls.Comparable):
pass
def test_load_m2o_attached_to_o2(self):
@classmethod
def setup_classes(cls):
- class Task_Type(_base.BasicEntity):
+ class Task_Type(cls.Basic):
pass
- class Joined(_base.ComparableEntity):
+ class Joined(cls.Comparable):
pass
@testing.fails_on('maxdb', 'FIXME: unknown')
@classmethod
def setup_classes(cls):
- class Account(_base.BasicEntity):
+ class Account(cls.Basic):
pass
- class Transaction(_base.BasicEntity):
+ class Transaction(cls.Basic):
pass
- class Entry(_base.BasicEntity):
+ class Entry(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
- class Order(_base.ComparableEntity):
+ class Order(cls.Comparable):
pass
- class Dingaling(_base.ComparableEntity):
+ class Dingaling(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Order(_base.ComparableEntity):
+ class Order(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Pref(_base.ComparableEntity):
+ class Pref(cls.Comparable):
pass
- class Extra(_base.ComparableEntity):
+ class Extra(cls.Comparable):
pass
- class Foo(_base.ComparableEntity):
+ class Foo(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
- class T2(_base.ComparableEntity):
+ class T2(cls.Comparable):
pass
- class T3(_base.ComparableEntity):
+ class T3(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
- class T2(_base.ComparableEntity):
+ class T2(cls.Comparable):
pass
- class T3(_base.ComparableEntity):
+ class T3(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
- class B(_base.ComparableEntity):
+ class B(cls.Comparable):
pass
- class C(_base.ComparableEntity):
+ class C(cls.Comparable):
pass
def test_delete_orphan(self):
)
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
- class Order(_base.ComparableEntity):
+ class Order(cls.Comparable):
pass
def test_pending_standalone_orphan(self):
@classmethod
def setup_classes(cls):
- class Order(_base.ComparableEntity):
+ class Order(cls.Comparable):
pass
- class Item(_base.ComparableEntity):
+ class Item(cls.Comparable):
pass
- class Attribute(_base.ComparableEntity):
+ class Attribute(cls.Comparable):
pass
def test_singlelevel_remove(self):
@classmethod
def setup_classes(cls):
- class Parent(_base.ComparableEntity):
+ class Parent(cls.Comparable):
pass
- class Child(_base.ComparableEntity):
+ class Child(cls.Comparable):
pass
def _do_move_test(self, delete_old):
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
def __init__(self, label=None):
self.label = label
- class Child(_base.BasicEntity):
+ class Child(cls.Basic):
def __init__(self, a=None, b=None, c=None):
self.a = a
self.b = b
def setup_mappers(cls):
graphs, edges = cls.tables.graphs, cls.tables.edges
- class Point(_base.BasicEntity):
+ class Point(cls.Basic):
def __init__(self, x, y):
self.x = x
self.y = y
return not isinstance(other, Point) or \
not self.__eq__(other)
- class Graph(_base.BasicEntity):
+ class Graph(cls.Basic):
pass
- class Edge(_base.BasicEntity):
+ class Edge(cls.Basic):
def __init__(self, *args):
if args:
self.start, self.end = args
def setup_mappers(cls):
graphs = cls.tables.graphs
- class Version(_base.BasicEntity):
+ class Version(cls.Basic):
def __init__(self, id, version):
self.id = id
self.version = version
def __ne__(self, other):
return not self.__eq__(other)
- class Graph(_base.BasicEntity):
+ class Graph(cls.Basic):
def __init__(self, version):
self.version = version
def setup_mappers(cls):
foobars = cls.tables.foobars
- class Foobar(_base.BasicEntity):
+ class Foobar(cls.Basic):
pass
- class FBComposite(_base.BasicEntity):
+ class FBComposite(cls.Basic):
def __init__(self, x1, x2, x3, x4):
self.x1 = x1
self.x2 = x2
def setup_mappers(cls):
values, descriptions = cls.tables.values, cls.tables.descriptions
- class Descriptions(_base.BasicEntity):
+ class Descriptions(cls.Basic):
pass
- class Values(_base.BasicEntity):
+ class Values(cls.Basic):
pass
- class CustomValues(_base.BasicEntity, list):
+ class CustomValues(cls.Basic, list):
def __init__(self, *args):
self.extend(args)
def setup_mappers(cls):
a, b = cls.tables.a, cls.tables.b
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
- class B(_base.ComparableEntity):
+ class B(cls.Comparable):
pass
- class C(_base.BasicEntity):
+ class C(cls.Basic):
def __init__(self, b1, b2):
self.b1, self.b2 = b1, b2
@classmethod
def setup_mappers(cls):
- class Point(_base.BasicEntity):
+ class Point(cls.Basic):
def __init__(self, x, y):
self.x = x
self.y = y
return not isinstance(other, Point) or \
not self.__eq__(other)
- class Edge(_base.ComparableEntity):
+ class Edge(cls.Comparable):
pass
def _test_roundtrip(self):
@classmethod
def setup_classes(cls):
- class C1(_base.BasicEntity):
+ class C1(cls.Basic):
def __init__(self, data=None):
self.data = data
- class C2(_base.BasicEntity):
+ class C2(cls.Basic):
def __init__(self, data=None):
self.data = data
@classmethod
def setup_classes(cls):
- class TT(_base.BasicEntity):
+ class TT(cls.Basic):
def __init__(self):
self.uuid = hex(id(self))
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
pass
class Child1(Parent):
@classmethod
def setup_classes(cls):
- class A(_base.BasicEntity):
+ class A(cls.Basic):
pass
class B(A):
pass
- class C(_base.BasicEntity):
+ class C(cls.Basic):
pass
def test_flush(self):
@classmethod
def setup_classes(cls):
- class T1(_base.BasicEntity):
+ class T1(cls.Basic):
pass
- class T2(_base.BasicEntity):
+ class T2(cls.Basic):
pass
- class T3(_base.BasicEntity):
+ class T3(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class C1(_base.BasicEntity):
+ class C1(cls.Basic):
pass
- class C2(_base.BasicEntity):
+ class C2(cls.Basic):
pass
def test_cycle(self):
@classmethod
def setup_classes(cls):
- class C1(_base.BasicEntity):
+ class C1(cls.Basic):
pass
- class C2(_base.BasicEntity):
+ class C2(cls.Basic):
pass
- class C1Data(_base.BasicEntity):
+ class C1Data(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Person(_base.ComparableEntity):
+ class Person(cls.Comparable):
pass
- class Ball(_base.ComparableEntity):
+ class Ball(cls.Comparable):
pass
def test_cycle(self):
@classmethod
def setup_classes(cls):
- class Node(_base.BasicEntity):
+ class Node(cls.Basic):
def __init__(self, path=''):
self.path = path
@classmethod
def setup_classes(cls):
- class A(_base.BasicEntity):
+ class A(cls.Basic):
pass
def test_one(self):
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
def __init__(self, name=''):
self.name = name
- class Child(_base.BasicEntity):
+ class Child(cls.Basic):
def __init__(self, name=''):
self.name = name
@classmethod
def setup_classes(cls):
- class Parent(_base.BasicEntity):
+ class Parent(cls.Basic):
def __init__(self, name=''):
self.name = name
- class Child1(_base.BasicEntity):
+ class Child1(cls.Basic):
def __init__(self, name=''):
self.name = name
- class Child2(_base.BasicEntity):
+ class Child2(cls.Basic):
def __init__(self, name=''):
self.name = name
- class Child3(_base.BasicEntity):
+ class Child3(cls.Basic):
def __init__(self, name=''):
self.name = name
@classmethod
def setup_classes(cls):
- class Default(_base.BasicEntity):
+ class Default(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.BasicEntity):
+ class User(cls.Basic):
pass
- class Address(_base.BasicEntity):
+ class Address(cls.Basic):
pass
@classmethod
def setup_mappers(cls):
users, addresses = cls.tables.users, cls.tables.addresses
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
mapper(User, users, properties={
def setup_mappers(cls):
b_table, a_table = cls.tables.b_table, cls.tables.a_table
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
- class B(_base.ComparableEntity):
+ class B(cls.Comparable):
pass
mapper(A,a_table)
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Person(_base.ComparableEntity):
+ class Person(cls.Comparable):
pass
class Engineer(Person):
pass
cls.tables.b,
cls.tables.d)
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
- class B(_base.ComparableEntity):
+ class B(cls.Comparable):
pass
class C(B):
def setup_mappers(cls):
foo = cls.tables.foo
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
mapper(Foo, foo)
def setup_mappers(cls):
table2, table1 = cls.tables.table2, cls.tables.table1
- class Obj1(_base.BasicEntity):
+ class Obj1(cls.Basic):
pass
- class Obj2(_base.BasicEntity):
+ class Obj2(cls.Basic):
pass
mapper(Obj1, table1)
def setup_mappers(cls):
Table2, Table1 = cls.tables.Table2, cls.tables.Table1
- class Obj1(_base.BasicEntity):
+ class Obj1(cls.Basic):
pass
- class Obj2(_base.BasicEntity):
+ class Obj2(cls.Basic):
pass
mapper(Obj1, Table1)
cls.tables.machines,
cls.tables.engineers)
- class Company(_base.ComparableEntity):
+ class Company(cls.Comparable):
pass
- class Person(_base.ComparableEntity):
+ class Person(cls.Comparable):
pass
class Engineer(Person):
pass
pass
class Boss(Manager):
pass
- class Machine(_base.ComparableEntity):
+ class Machine(cls.Comparable):
pass
- class Paperwork(_base.ComparableEntity):
+ class Paperwork(cls.Comparable):
pass
mapper(Company, companies, properties={
cls.tables.assoc_table,
cls.tables.sub_table)
- class Node(_base.ComparableEntity):
+ class Node(cls.Comparable):
pass
- class Sub(_base.ComparableEntity):
+ class Sub(cls.Comparable):
pass
mapper(Node, nodes, properties={
@classmethod
def setup_classes(cls):
- class Node(_base.ComparableEntity):
+ class Node(cls.Comparable):
def append(self, node):
self.children.append(node)
@classmethod
def setup_classes(cls):
- class Node(_base.ComparableEntity):
+ class Node(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Place(_base.BasicEntity):
+ class Place(cls.Basic):
def __init__(self, name=None):
self.name = name
def __str__(self):
return "(Place '%s')" % self.name
__repr__ = __str__
- class PlaceThingy(_base.BasicEntity):
+ class PlaceThingy(cls.Basic):
def __init__(self, name=None):
self.name = name
- class Transition(_base.BasicEntity):
+ class Transition(cls.Basic):
def __init__(self, name=None):
self.name = name
self.inputs = []
@classmethod
def setup_classes(cls):
- class Student(_base.BasicEntity):
+ class Student(cls.Basic):
def __init__(self, name=''):
self.name = name
- class Course(_base.BasicEntity):
+ class Course(cls.Basic):
def __init__(self, name=''):
self.name = name
cls.tables.base,
cls.tables.related)
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class Child1(Base):
pass
class Child2(Base):
pass
- class Related(_base.ComparableEntity):
+ class Related(cls.Comparable):
pass
mapper(Base, base, polymorphic_on=base.c.type, properties={
'related':relationship(Related, uselist=False)
def setup_mappers(cls):
thing, human = cls.tables.thing, cls.tables.human
- class Human(_base.BasicEntity): pass
- class Thing(_base.BasicEntity): pass
+ class Human(cls.Basic): pass
+ class Thing(cls.Basic): pass
mapper(Human, human, properties={"thing": relationship(Thing)})
mapper(Thing, thing, properties={"name": deferred(thing.c.name)})
@classmethod
def setup_classes(cls):
- class Cartographer(_base.BasicEntity):
+ class Cartographer(cls.Basic):
pass
- class Map(_base.BasicEntity):
+ class Map(cls.Basic):
pass
def test_mappish(self):
@classmethod
def setup_classes(cls):
- class Data(_base.ComparableEntity):
+ class Data(cls.Comparable):
pass
def test_list(self):
@classmethod
def setup_classes(cls):
- class Data(_base.ComparableEntity):
+ class Data(cls.Comparable):
pass
def test_merge_allow_partial(self):
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
- class Item(_base.ComparableEntity):
+ class Item(cls.Comparable):
pass
def test_entity(self):
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
def __init__(self, code, status, username):
self.code = code
self.status = status
@classmethod
def setup_classes(cls):
- class Node(_base.ComparableEntity):
+ class Node(cls.Comparable):
pass
def test_one_to_many_on_m2o(self):
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
@testing.fails_on('sqlite', 'sqlite doesnt support ON UPDATE CASCADE')
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
@testing.fails_on('sqlite', 'sqlite doesnt support ON UPDATE CASCADE')
@classmethod
def setup_classes(cls):
- class Person(_base.ComparableEntity):
+ class Person(cls.Comparable):
pass
class Engineer(Person):
pass
@classmethod
def setup_mappers(cls):
- class Jack(_base.BasicEntity):
+ class Jack(cls.Basic):
pass
- class Port(_base.BasicEntity):
+ class Port(cls.Basic):
pass
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Document(_base.ComparableEntity):
+ class Document(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class A(_base.Entity):
+ class A(cls.Basic):
pass
- class B(_base.Entity):
+ class B(cls.Basic):
pass
- class C(_base.Entity):
+ class C(cls.Basic):
pass
- class D(_base.Entity):
+ class D(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Company(_base.Entity):
+ class Company(cls.Basic):
pass
- class Employee(_base.Entity):
+ class Employee(cls.Basic):
def __init__(self, name, company, emp_id, reports_to=None):
self.name = name
self.company = company
cls.tables.jobs,
cls.tables.pages)
- class Job(_base.Entity):
+ class Job(cls.Basic):
def create_page(self, pagename):
return Page(job=self, pagename=pagename)
- class PageVersion(_base.Entity):
+ class PageVersion(cls.Basic):
def __init__(self, page=None, version=None):
self.page = page
self.version = version
- class Page(_base.Entity):
+ class Page(cls.Basic):
def __init__(self, job=None, pagename=None):
self.job = job
self.pagename = pagename
self.comments.append(newcomment)
newcomment.created_version = self.currentversion.version
return newcomment
- class PageComment(_base.Entity):
+ class PageComment(cls.Basic):
pass
mapper(Job, jobs)
@classmethod
def setup_classes(cls):
- class A(_base.Entity):
+ class A(cls.Basic):
pass
- class B(_base.Entity):
+ class B(cls.Basic):
pass
def test_onetoone_switch(self):
primary_key=True, autoincrement=False, nullable=True))
tableC.create()
- class C(_base.Entity):
+ class C(_base.BasicEntity):
pass
mapper(C, tableC, properties={
'a':relationship(A, cascade="save-update")
@classmethod
def setup_classes(cls):
- class A(_base.ComparableEntity):
+ class A(cls.Comparable):
pass
- class B(_base.ComparableEntity):
+ class B(cls.Comparable):
pass
def test_switch_parent(self):
def test_basic(self):
items = self.tables.items
- class Container(_base.Entity):
+ class Container(_base.BasicEntity):
pass
- class LineItem(_base.Entity):
+ class LineItem(_base.BasicEntity):
pass
container_select = sa.select(
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
def test_backref(self):
and_(address.c.subscriber_id==subscriber.c.id,
address.c.type.in_(['A', 'B', 'C'])))
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
- class Subscriber(_base.ComparableEntity):
+ class Subscriber(cls.Comparable):
pass
mapper(Address, address)
self.tables.c,
self.tables.b)
- class A(_base.Entity): pass
- class B(_base.Entity): pass
- class C(_base.Entity): pass
+ class A(_base.BasicEntity): pass
+ class B(_base.BasicEntity): pass
+ class C(_base.BasicEntity): pass
mapper(A, a, properties={'bs':relationship(B)})
mapper(B, b)
mapper(C, c)
self.tables.c,
self.tables.b)
- class A(_base.Entity): pass
- class B(_base.Entity): pass
- class C(_base.Entity): pass
+ class A(_base.BasicEntity): pass
+ class B(_base.BasicEntity): pass
+ class C(_base.BasicEntity): pass
mapper(A, a, properties={'bs':relationship(B, cascade="none")})
mapper(B, b)
mapper(C, c)
self.tables.c,
self.tables.b)
- class A(_base.Entity): pass
- class B(_base.Entity): pass
+ class A(_base.BasicEntity): pass
+ class B(_base.BasicEntity): pass
class C(B): pass
mapper(A, a, properties={'bs':relationship(B, cascade="none")})
mapper(B, b)
self.tables.b,
self.tables.d)
- class A(_base.Entity): pass
+ class A(_base.BasicEntity): pass
class B(A): pass
- class D(_base.Entity): pass
+ class D(_base.BasicEntity): pass
mapper(A, a)
mapper(B, b, inherits=A)
mapper(D, d, properties={"a":relationship(A, cascade="none")})
self.tables.b,
self.tables.d)
- class A(_base.Entity): pass
- class B(_base.Entity): pass
- class D(_base.Entity): pass
+ class A(_base.BasicEntity): pass
+ class B(_base.BasicEntity): pass
+ class D(_base.BasicEntity): pass
mapper(A, a)
mapper(B, b)
mapper(D, d, properties={"a":relationship(A)})
"""Many-to-many tables with special types for candidate keys."""
- class T1(_base.Entity): pass
- class T2(_base.Entity): pass
+ class T1(_base.BasicEntity): pass
+ class T2(_base.BasicEntity): pass
mapper(T2, t2)
mapper(T1, t1, properties={
't2s':relationship(T2, secondary=t3, backref='t1s')})
error.
"""
- class C1(_base.Entity): pass
- class C2(_base.Entity): pass
- class C3(_base.Entity): pass
+ class C1(_base.BasicEntity): pass
+ class C2(_base.BasicEntity): pass
+ class C3(_base.BasicEntity): pass
mapper(C1, t1, properties={
't2s':relationship(C2),
PK column names and should not produce 'mapper has no columnX' error.
"""
- class C1(_base.Entity): pass
- class C2(_base.Entity): pass
- class C3(_base.Entity): pass
+ class C1(_base.BasicEntity): pass
+ class C2(_base.BasicEntity): pass
+ class C3(_base.BasicEntity): pass
mapper(C1, t1, properties={
't2s':relationship(C2),
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
- class T2(_base.ComparableEntity):
+ class T2(cls.Comparable):
pass
- class T3(_base.ComparableEntity):
+ class T3(cls.Comparable):
pass
def test_basic(self):
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
- class T2(_base.ComparableEntity):
+ class T2(cls.Comparable):
pass
def test_onetomany_funcfk(self):
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
def test_o2m_backref(self):
@classmethod
def setup_classes(cls):
- class Foo(_base.Entity):
+ class Foo(cls.Basic):
pass
- class Bar(_base.Entity):
+ class Bar(cls.Basic):
pass
def test_no_join(self):
@classmethod
def setup_classes(cls):
- class Foo(_base.Entity):
+ class Foo(cls.Basic):
pass
- class Bar(_base.Entity):
+ class Bar(cls.Basic):
pass
def test_no_join(self):
@classmethod
def setup_classes(cls):
- class User(_base.BasicEntity):
+ class User(cls.Basic):
pass
- class Address(_base.BasicEntity):
+ class Address(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Subset(_base.ComparableEntity):
+ class Subset(cls.Comparable):
pass
def test_no_tables(self):
@classmethod
def setup_classes(cls):
- class User(_base.BasicEntity):
+ class User(cls.Basic):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
def test_rollback_recover(self):
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
- class Address(_base.ComparableEntity):
+ class Address(cls.Comparable):
pass
def test_backref(self):
@classmethod
def setup_classes(cls):
- class Test(_base.BasicEntity):
+ class Test(cls.Basic):
pass
- class Test2(_base.BasicEntity):
+ class Test2(cls.Basic):
pass
def test_basic(self):
@classmethod
def setup_classes(cls):
- class Foo(_base.BasicEntity):
+ class Foo(cls.Basic):
pass
def test_binary_equality(self):
@classmethod
def setup_classes(cls):
- class Entry(_base.BasicEntity):
+ class Entry(cls.Basic):
pass
# not supported on sqlite since sqlite's auto-pk generation only works with
@classmethod
def setup_classes(cls):
- class Person(_base.BasicEntity):
+ class Person(cls.Basic):
pass
- class PersonSite(_base.BasicEntity):
+ class PersonSite(cls.Basic):
pass
def test_basic(self):
@classmethod
def setup_classes(cls):
- class User(_base.ComparableEntity):
+ class User(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class MyClass(_base.BasicEntity):
+ class MyClass(cls.Basic):
pass
- class MyOtherClass(_base.BasicEntity):
+ class MyOtherClass(cls.Basic):
pass
def test_basic(self):
@classmethod
def setup_classes(cls):
- class MyClass(_base.BasicEntity):
+ class MyClass(cls.Basic):
pass
- class MyOtherClass(_base.BasicEntity):
+ class MyOtherClass(cls.Basic):
pass
def test_assertions(self):
@classmethod
def setup_classes(cls):
- class Hoho(_base.ComparableEntity):
+ class Hoho(cls.Comparable):
pass
- class Secondary(_base.ComparableEntity):
+ class Secondary(cls.Comparable):
pass
@testing.fails_on('firebird', 'Data type unknown on the parameter')
@classmethod
def setup_mappers(cls):
- class Data(_base.BasicEntity):
+ class Data(cls.Basic):
pass
def test_refreshes(self):
@classmethod
def setup_classes(cls):
- class Keyword(_base.BasicEntity):
+ class Keyword(cls.Basic):
pass
- class Item(_base.BasicEntity):
+ class Item(cls.Basic):
pass
def test_manytomany_xtracol_delete(self):
@classmethod
def setup_classes(cls):
- class T5(_base.ComparableEntity):
+ class T5(cls.Comparable):
pass
- class T6(_base.ComparableEntity):
+ class T6(cls.Comparable):
pass
- class T7(_base.ComparableEntity):
+ class T7(cls.Comparable):
pass
def test_onetomany(self):
@classmethod
def setup_classes(cls):
- class P(_base.ComparableEntity):
+ class P(cls.Comparable):
pass
class C(P):
))
@classmethod
def setup_classes(cls):
- class T1(_base.ComparableEntity):
+ class T1(cls.Comparable):
pass
- class T2(_base.ComparableEntity):
+ class T2(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Foo(_base.ComparableEntity):
+ class Foo(cls.Comparable):
pass
def _fixture(self):
@classmethod
def setup_classes(cls):
- class P(_base.ComparableEntity):
+ class P(cls.Comparable):
pass
- class C(_base.ComparableEntity):
+ class C(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class P(_base.ComparableEntity):
+ class P(cls.Comparable):
pass
- class C(_base.ComparableEntity):
+ class C(cls.Comparable):
pass
@classmethod
@classmethod
def setup_classes(cls):
- class Base(_base.ComparableEntity):
+ class Base(cls.Comparable):
pass
class Sub(Base):
pass
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
