root / elixir / trunk / tests / test_autoload.py

Revision 530, 11.5 kB (checked in by ged, 21 months ago)

added more autoload tests

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        conn = metadata.bind.connect()
36        conn.execute("CREATE TABLE a ("
37                     "id INTEGER PRIMARY KEY AUTOINCREMENT,"
38                     "name VARCHAR(32))")
39        conn.close()
40
41        class A(Entity):
42            pass
43
44        setup_all()
45
46        a1 = A(name="a1")
47        a2 = A(name="a2")
48
49        session.commit()
50        session.expunge_all()
51
52        a1 = A.get_by(name="a1")
53        a2 = A.get_by(name="a2")
54        assert a1.name == 'a1'
55        assert a2.name == 'a2'
56
57    def test_fk_auto_join_sa(self):
58        # SQLAlchemy produces the join in this case
59        person_table = Table('person', metadata,
60            Column('id', Integer, primary_key=True),
61            Column('name', String(32)))
62
63        animal_table = Table('animal', metadata,
64            Column('id', Integer, primary_key=True),
65            Column('name', String(30)),
66            Column('owner_id', Integer, ForeignKey('person.id')))
67
68        metadata.create_all()
69        metadata.clear()
70
71        class Person(Entity):
72            pets = OneToMany('Animal')
73
74        class Animal(Entity):
75            owner = ManyToOne('Person')
76
77        setup_all()
78
79        snowball = Animal(name="Snowball")
80        snowball2 = Animal(name="Snowball II")
81        slh = Animal(name="Santa's Little Helper")
82        homer = Person(name="Homer", pets=[slh, snowball])
83        lisa = Person(name="Lisa", pets=[snowball2])
84
85        session.commit()
86        session.expunge_all()
87
88        homer = Person.get_by(name="Homer")
89        lisa = Person.get_by(name="Lisa")
90        slh = Animal.get_by(name="Santa's Little Helper")
91
92        assert len(homer.pets) == 2
93        assert homer == slh.owner
94        assert lisa.pets[0].name == "Snowball II"
95
96    def test_fk_auto_join_colname(self):
97        person_table = Table('person', metadata,
98            Column('id', Integer, primary_key=True),
99            Column('name', String(32)))
100
101        animal_table = Table('animal', metadata,
102            Column('id', Integer, primary_key=True),
103            Column('name', String(30)),
104            Column('owner_id', Integer, ForeignKey('person.id')),
105            Column('feeder_id', Integer, ForeignKey('person.id')))
106
107        metadata.create_all()
108        metadata.clear()
109
110        class Person(Entity):
111            pets = OneToMany('Animal', inverse='owner')
112            animals = OneToMany('Animal', inverse='feeder')
113
114        class Animal(Entity):
115            owner = ManyToOne('Person', colname='owner_id')
116            feeder = ManyToOne('Person', colname='feeder_id')
117
118        setup_all()
119
120        snowball = Animal(name="Snowball II")
121        slh = Animal(name="Santa's Little Helper")
122        homer = Person(name="Homer", animals=[snowball, slh], pets=[slh])
123        lisa = Person(name="Lisa", pets=[snowball])
124
125        session.commit()
126        session.expunge_all()
127
128        homer = Person.get_by(name="Homer")
129        lisa = Person.get_by(name="Lisa")
130        slh = Animal.get_by(name="Santa's Little Helper")
131
132        assert len(homer.animals) == 2
133        assert homer == lisa.pets[0].feeder
134        assert homer == slh.owner
135
136    def test_selfref(self):
137        person_table = Table('person', metadata,
138            Column('id', Integer, primary_key=True),
139            Column('father_id', Integer, ForeignKey('person.id')),
140            Column('name', String(32)))
141
142        metadata.create_all()
143        metadata.clear()
144
145        class Person(Entity):
146            father = ManyToOne('Person')
147            children = OneToMany('Person')
148
149        setup_all()
150
151        grampa = Person(name="Abe")
152        homer = Person(name="Homer")
153        bart = Person(name="Bart")
154        lisa = Person(name="Lisa")
155
156        grampa.children.append(homer)
157        homer.children.append(bart)
158        lisa.father = homer
159
160        session.commit()
161        session.expunge_all()
162
163        p = Person.get_by(name="Homer")
164
165        assert p in p.father.children
166        assert p.father.name == "Abe"
167        assert p.father is Person.get_by(name="Abe")
168        assert p is Person.get_by(name="Lisa").father
169
170    def test_m2m(self):
171        person_table = Table('person', metadata,
172            Column('id', Integer, primary_key=True),
173            Column('name', String(32)))
174
175        category_table = Table('category', metadata,
176            Column('name', String(30), primary_key=True))
177
178        person_category_table = Table('person_category', metadata,
179            Column('person_id', Integer, ForeignKey('person.id')),
180            Column('category_name', String(30), ForeignKey('category.name')))
181
182        metadata.create_all()
183        metadata.clear()
184
185        class Person(Entity):
186            categories = ManyToMany('Category',
187                                    tablename='person_category')
188
189        class Category(Entity):
190            persons = ManyToMany('Person',
191                                 tablename='person_category')
192
193        setup_all()
194
195        stupid = Category(name="Stupid")
196        simpson = Category(name="Simpson")
197        old = Category(name="Old")
198
199        grampa = Person(name="Abe", categories=[simpson, old])
200        homer = Person(name="Homer", categories=[simpson, stupid])
201        bart = Person(name="Bart")
202        lisa = Person(name="Lisa")
203
204        simpson.persons.extend([bart, lisa])
205
206        session.commit()
207        session.expunge_all()
208
209        c = Category.get_by(name="Simpson")
210        grampa = Person.get_by(name="Abe")
211
212        assert len(c.persons) == 4
213        assert c in grampa.categories
214
215     # currently fails. See elixir/relationships.py:_get_join_clauses
216#    def test_m2m_extra_fk(self):
217#        person_table = Table('person', metadata,
218#            Column('id', Integer, primary_key=True),
219#            Column('name', String(32), unique=True))
220#
221#        category_table = Table('category', metadata,
222#            Column('name', String(30), primary_key=True))
223#
224#        person_category_table = Table('person_category', metadata,
225#            Column('person_id', Integer, ForeignKey('person.id')),
226#            Column('category_name', String(30), ForeignKey('category.name')),
227#            Column('person_name', String(32), ForeignKey('person.name')))
228#
229#        metadata.create_all()
230#        metadata.clear()
231#
232#        class Person(Entity):
233#            categories = ManyToMany('Category',
234#                                    tablename='person_category',
235#                                    local_colname='person_id')
236#
237#        class Category(Entity):
238#            persons = ManyToMany('Person',
239#                                 tablename='person_category')
240#
241#        setup_all()
242#
243#        stupid = Category(name="Stupid")
244#        simpson = Category(name="Simpson")
245#        old = Category(name="Old")
246#
247#        grampa = Person(name="Abe", categories=[simpson, old])
248#        homer = Person(name="Homer", categories=[simpson, stupid])
249#        bart = Person(name="Bart")
250#        lisa = Person(name="Lisa")
251#
252#        simpson.persons.extend([bart, lisa])
253#
254#        session.commit()
255#        session.expunge_all()
256#
257#        c = Category.get_by(name="Simpson")
258#        grampa = Person.get_by(name="Abe")
259#
260#        assert len(c.persons) == 4
261#        assert c in grampa.categories
262
263    def test_m2m_selfref(self):
264        person_table = Table('person', metadata,
265            Column('id', Integer, primary_key=True),
266            Column('name', String(32)))
267
268        person_person_table = Table('person_person', metadata,
269            Column('person_id1', Integer, ForeignKey('person.id')),
270            Column('person_id2', Integer, ForeignKey('person.id')))
271
272        metadata.create_all()
273        metadata.clear()
274
275        class Person(Entity):
276            appreciate = ManyToMany('Person',
277                                    tablename='person_person',
278                                    local_colname='person_id1')
279            isappreciatedby = ManyToMany('Person',
280                                         tablename='person_person',
281                                         # this one is not necessary
282                                         local_colname='person_id2')
283
284        setup_all()
285
286        barney = Person(name="Barney")
287        homer = Person(name="Homer", appreciate=[barney])
288
289        session.commit()
290        session.expunge_all()
291
292        homer = Person.get_by(name="Homer")
293        barney = Person.get_by(name="Barney")
294
295        assert barney in homer.appreciate
296        assert homer in barney.isappreciatedby
297
298    # ----------------
299    # overrides tests
300    # ----------------
301    def _create_table_a(self):
302        a_table = Table('a', metadata,
303            Column('id', Integer, primary_key=True),
304            Column('name', String(32)))
305
306        metadata.create_all()
307        metadata.clear()
308
309    def test_override_pk_fails(self):
310        self._create_table_a()
311
312        class A(Entity):
313            id = Field(Integer, primary_key=True)
314
315        setup_entity_raise(A)
316
317    def test_override_non_pk_fails(self):
318        self._create_table_a()
319
320        class A(Entity):
321            name = Field(String(30))
322
323        setup_entity_raise(A)
324
325    def test_override_pk(self):
326        self._create_table_a()
327
328        class A(Entity):
329            using_options(allowcoloverride=True)
330
331            id = Field(Integer, primary_key=True)
332
333        setup_entities([A])
334
335    def test_override_non_pk(self):
336        self._create_table_a()
337
338        class A(Entity):
339            using_options(allowcoloverride=True)
340
341            name = Field(String(30))
342
343        setup_entities([A])
344        assert isinstance(A.table.columns['name'].type, String)
345
346    # ---------------
347
348    def test_nopk(self):
349        table = Table('a', metadata,
350            Column('id', Integer),
351            Column('name', String(32)))
352
353        metadata.create_all()
354        metadata.clear()
355
356        class A(Entity):
357            using_mapper_options(primary_key=['id'])
358
359        setup_all()
360
361        a1 = A(id=1, name="a1")
362
363        session.commit()
364        session.expunge_all()
365
366        res = A.query.all()
367
368        assert len(res) == 1
369        assert res[0].name == "a1"
370
371    def test_inheritance(self):
372        table = Table('father', metadata,
373            Column('id', Integer, primary_key=True),
374            Column('row_type', elixir.options.POLYMORPHIC_COL_TYPE))
375
376        metadata.create_all()
377        metadata.clear()
378
379        class Father(Entity):
380            pass
381
382        class Son(Father):
383            pass
384
385        setup_all()
386
387    def test_autoload_mixed(self):
388        # mixed autoloaded entity with a non autoloaded one
389        conn = metadata.bind.connect()
390        conn.execute("CREATE TABLE user ("
391                     "user_id INTEGER PRIMARY KEY AUTOINCREMENT)")
392        conn.close()
393
394        class User(Entity):
395            using_options(tablename='user', autoload=True)
396
397        class Item(Entity):
398            using_options(autoload=False)
399
400            owner = ManyToOne('User')
401
402        setup_all(True)
403
404        colname = Item.table.c['owner_user_id'].foreign_keys[0].column.name
405        assert colname == 'user_id'
Note: See TracBrowser for help on using the browser.