root / elixir / tags / 0.7.0 / tests / test_autoload.py

Revision 474, 8.0 kB (checked in by ged, 3 years ago)

fix autoload test

Line 
1"""
2test autoloaded entities
3"""
4
5from sqlalchemy import Table, Column, ForeignKey
6from elixir import *
7import elixir
8
9def setup_entity_raise(cls):
10    try:
11        setup_entities([cls])
12    except Exception, e:
13        pass
14    else:
15        assert False, "Exception did not occur setting up %s" % cls.__name__
16
17# ------
18
19def setup():
20    elixir.options_defaults.update(dict(autoload=True, shortnames=True))
21
22def teardown():
23    elixir.options_defaults.update(dict(autoload=False, shortnames=False))
24
25# -----------
26
27class TestAutoload(object):
28    def setup(self):
29        metadata.bind = 'sqlite://'
30
31    def teardown(self):
32        cleanup_all(True)
33
34    def test_simple(self):
35        person_table = Table('person', metadata,
36            Column('id', Integer, primary_key=True),
37            Column('name', String(32)))
38
39        animal_table = Table('animal', metadata,
40            Column('id', Integer, primary_key=True),
41            Column('name', String(30)),
42            Column('owner_id', Integer, ForeignKey('person.id')),
43            Column('feeder_id', Integer, ForeignKey('person.id')))
44
45        metadata.create_all()
46        metadata.clear()
47
48        class Person(Entity):
49            pets = OneToMany('Animal', inverse='owner')
50            animals = OneToMany('Animal', inverse='feeder')
51
52        class Animal(Entity):
53            owner = ManyToOne('Person', colname='owner_id')
54            feeder = ManyToOne('Person', colname='feeder_id')
55
56        setup_all()
57
58        snowball = Animal(name="Snowball II")
59        slh = Animal(name="Santa's Little Helper")
60        homer = Person(name="Homer", animals=[snowball, slh], pets=[slh])
61        lisa = Person(name="Lisa", pets=[snowball])
62
63        session.commit()
64        session.clear()
65
66        homer = Person.get_by(name="Homer")
67        lisa = Person.get_by(name="Lisa")
68        slh = Animal.get_by(name="Santa's Little Helper")
69
70        assert len(homer.animals) == 2
71        assert homer == lisa.pets[0].feeder
72        assert homer == slh.owner
73
74    def test_selfref(self):
75        person_table = Table('person', metadata,
76            Column('id', Integer, primary_key=True),
77            Column('father_id', Integer, ForeignKey('person.id')),
78            Column('name', String(32)))
79
80        metadata.create_all()
81        metadata.clear()
82
83        class Person(Entity):
84            father = ManyToOne('Person')
85            children = OneToMany('Person')
86
87        setup_all()
88
89        grampa = Person(name="Abe")
90        homer = Person(name="Homer")
91        bart = Person(name="Bart")
92        lisa = Person(name="Lisa")
93
94        grampa.children.append(homer)
95        homer.children.append(bart)
96        lisa.father = homer
97
98        session.commit()
99        session.clear()
100
101        p = Person.get_by(name="Homer")
102
103        assert p in p.father.children
104        assert p.father.name == "Abe"
105        assert p.father is Person.get_by(name="Abe")
106        assert p is Person.get_by(name="Lisa").father
107
108    def test_m2m(self):
109        person_table = Table('person', metadata,
110            Column('id', Integer, primary_key=True),
111            Column('name', String(32)))
112
113        category_table = Table('category', metadata,
114            Column('name', String(30), primary_key=True))
115
116        person_category_table = Table('person_category', metadata,
117            Column('person_id', Integer, ForeignKey('person.id')),
118            Column('category_name', String(30), ForeignKey('category.name')))
119
120        metadata.create_all()
121        metadata.clear()
122
123        class Person(Entity):
124            categories = ManyToMany('Category',
125                                    tablename='person_category')
126
127        class Category(Entity):
128            persons = ManyToMany('Person',
129                                 tablename='person_category')
130
131        setup_all()
132
133        stupid = Category(name="Stupid")
134        simpson = Category(name="Simpson")
135        old = Category(name="Old")
136
137        grampa = Person(name="Abe", categories=[simpson, old])
138        homer = Person(name="Homer", categories=[simpson, stupid])
139        bart = Person(name="Bart")
140        lisa = Person(name="Lisa")
141
142        simpson.persons.extend([bart, lisa])
143
144        session.commit()
145        session.clear()
146
147        c = Category.get_by(name="Simpson")
148        grampa = Person.get_by(name="Abe")
149
150        assert len(c.persons) == 4
151        assert c in grampa.categories
152
153    def test_m2m_selfref(self):
154        person_table = Table('person', metadata,
155            Column('id', Integer, primary_key=True),
156            Column('name', String(32)))
157
158        person_person_table = Table('person_person', metadata,
159            Column('person_id1', Integer, ForeignKey('person.id')),
160            Column('person_id2', Integer, ForeignKey('person.id')))
161
162        metadata.create_all()
163        metadata.clear()
164
165        class Person(Entity):
166            appreciate = ManyToMany('Person',
167                                    tablename='person_person',
168                                    local_colname='person_id1')
169            isappreciatedby = ManyToMany('Person',
170                                         tablename='person_person',
171                                         local_colname='person_id2')
172
173        setup_all()
174
175        barney = Person(name="Barney")
176        homer = Person(name="Homer", appreciate=[barney])
177
178        session.commit()
179        session.clear()
180
181        homer = Person.get_by(name="Homer")
182        barney = Person.get_by(name="Barney")
183
184        assert barney in homer.appreciate
185        assert homer in barney.isappreciatedby
186
187    # ----------------
188    # overrides tests
189    # ----------------
190    def _create_table_a(self):
191        a_table = Table('a', metadata,
192            Column('id', Integer, primary_key=True),
193            Column('name', String(32)))
194
195        metadata.create_all()
196        metadata.clear()
197
198    def test_override_pk_fails(self):
199        self._create_table_a()
200
201        class A(Entity):
202            id = Field(Integer, primary_key=True)
203
204        setup_entity_raise(A)
205
206    def test_override_non_pk_fails(self):
207        self._create_table_a()
208
209        class A(Entity):
210            name = Field(String(30))
211
212        setup_entity_raise(A)
213
214    def test_override_pk(self):
215        self._create_table_a()
216
217        class A(Entity):
218            using_options(allowcoloverride=True)
219
220            id = Field(Integer, primary_key=True)
221
222        setup_entities([A])
223
224    def test_override_non_pk(self):
225        self._create_table_a()
226
227        class A(Entity):
228            using_options(allowcoloverride=True)
229
230            name = Field(String(30))
231
232        setup_entities([A])
233        assert isinstance(A.table.columns['name'].type, String)
234
235    # ---------------
236
237    def test_nopk(self):
238        table = Table('a', metadata,
239            Column('id', Integer),
240            Column('name', String(32)))
241
242        metadata.create_all()
243        metadata.clear()
244
245        class A(Entity):
246            using_mapper_options(primary_key=['id'])
247
248        setup_all()
249
250        a1 = A(id=1, name="a1")
251
252        session.commit()
253        session.clear()
254
255        res = A.query.all()
256
257        assert len(res) == 1
258        assert res[0].name == "a1"
259
260    def test_inheritance(self):
261        table = Table('father', metadata,
262            Column('id', Integer, primary_key=True),
263            Column('row_type', elixir.options.POLYMORPHIC_COL_TYPE))
264
265        metadata.create_all()
266        metadata.clear()
267
268        class Father(Entity):
269            pass
270
271        class Son(Father):
272            pass
273
274        setup_all()
275
276    def test_autoload_mixed(self):
277        # mixed autoloaded entity with a non autoloaded one
278        conn = metadata.bind.connect()
279        conn.execute("CREATE TABLE user ("
280                     "user_id INTEGER PRIMARY KEY AUTOINCREMENT)")
281        conn.close()
282
283        class User(Entity):
284            using_options(tablename='user', autoload=True)
285
286        class Item(Entity):
287            using_options(autoload=False)
288
289            owner = ManyToOne('User')
290
291        setup_all(True)
292
293        colname = Item.table.c['owner_user_id'].foreign_keys[0].column.name
294        assert colname == 'user_id'
Note: See TracBrowser for help on using the browser.