← Back to branch summary

~ubuntu-branches/debian/jessie/sqlalchemy/jessie

« back to all changes in this revision

Viewing changes to test/orm/_fixtures.py

  • Committer: Bazaar Package Importer
  • Author(s): Piotr Ożarowski
  • Date: 2011-08-01 23:18:16 UTC
  • mfrom: (1.4.15 upstream) (16.1.14 experimental)
  • Revision ID: james.westby@ubuntu.com-20110801231816-6lx797pi3q1fpqst
Tags: 0.7.2-1
http://bugs.debian.org/635898
* New upstream release
* Bump minimum required python-mako version to 0.4.1 (closes: 635898)

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/orm/_fixtures.py
1
1
from sqlalchemy import MetaData, Integer, String, ForeignKey
2
 
from sqlalchemy.test.schema import Table
3
 
from sqlalchemy.test.schema import Column
 
2
from sqlalchemy import util
 
3
from test.lib.schema import Table
 
4
from test.lib.schema import Column
4
5
from sqlalchemy.orm import attributes
5
 
from sqlalchemy.test.testing import fixture
6
 
from test.orm import _base
 
6
from test.lib import fixtures
7
7
 
8
8
__all__ = ()
9
9
 
10
 
fixture_metadata = MetaData()
11
 
 
12
 
def fixture_table(table, columns, *rows):
13
 
    def load_fixture(bind=None):
14
 
        bind = bind or table.bind
15
 
        if rows:
16
 
            bind.execute(
17
 
                table.insert(),
18
 
                [dict(zip(columns, column_values)) for column_values in rows])
19
 
    table.info[('fixture', 'loader')] = load_fixture
20
 
    table.info[('fixture', 'columns')] = columns
21
 
    table.info[('fixture', 'rows')] = rows
22
 
    return table
23
 
 
24
 
users = fixture_table(
25
 
    Table('users', fixture_metadata,
26
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
27
 
          Column('name', String(30), nullable=False),
28
 
          test_needs_acid=True,
29
 
          test_needs_fk=True),
30
 
    ('id', 'name'),
31
 
    (7, 'jack'),
32
 
    (8, 'ed'),
33
 
    (9, 'fred'),
34
 
    (10, 'chuck'))
35
 
 
36
 
addresses = fixture_table(
37
 
    Table('addresses', fixture_metadata,
38
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
39
 
          Column('user_id', None, ForeignKey('users.id')),
40
 
          Column('email_address', String(50), nullable=False),
41
 
          test_needs_acid=True,
42
 
          test_needs_fk=True),
43
 
    ('id', 'user_id', 'email_address'),
44
 
    (1, 7, "jack@bean.com"),
45
 
    (2, 8, "ed@wood.com"),
46
 
    (3, 8, "ed@bettyboop.com"),
47
 
    (4, 8, "ed@lala.com"),
48
 
    (5, 9, "fred@fred.com"))
49
 
 
50
 
email_bounces = fixture_table(
51
 
    Table('email_bounces', fixture_metadata,
52
 
          Column('id', Integer, ForeignKey('addresses.id')),
53
 
          Column('bounces', Integer)),
54
 
    ('id', 'bounces'),
55
 
    (1, 1),
56
 
    (2, 0),
57
 
    (3, 5),
58
 
    (4, 0),
59
 
    (5, 0))
60
 
 
61
 
orders = fixture_table(
62
 
    Table('orders', fixture_metadata,
63
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
64
 
          Column('user_id', None, ForeignKey('users.id')),
65
 
          Column('address_id', None, ForeignKey('addresses.id')),
66
 
          Column('description', String(30)),
67
 
          Column('isopen', Integer),
68
 
          test_needs_acid=True,
69
 
          test_needs_fk=True),
70
 
    ('id', 'user_id', 'description', 'isopen', 'address_id'),
71
 
    (1, 7, 'order 1', 0, 1),
72
 
    (2, 9, 'order 2', 0, 4),
73
 
    (3, 7, 'order 3', 1, 1),
74
 
    (4, 9, 'order 4', 1, 4),
75
 
    (5, 7, 'order 5', 0, None))
76
 
 
77
 
dingalings = fixture_table(
78
 
    Table("dingalings", fixture_metadata,
79
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
80
 
          Column('address_id', None, ForeignKey('addresses.id')),
81
 
          Column('data', String(30)),
82
 
          test_needs_acid=True,
83
 
          test_needs_fk=True),
84
 
    ('id', 'address_id', 'data'),
85
 
    (1, 2, 'ding 1/2'),
86
 
    (2, 5, 'ding 2/5'))
87
 
 
88
 
items = fixture_table(
89
 
    Table('items', fixture_metadata,
90
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
91
 
          Column('description', String(30), nullable=False),
92
 
          test_needs_acid=True,
93
 
          test_needs_fk=True),
94
 
    ('id', 'description'),
95
 
    (1, 'item 1'),
96
 
    (2, 'item 2'),
97
 
    (3, 'item 3'),
98
 
    (4, 'item 4'),
99
 
    (5, 'item 5'))
100
 
 
101
 
order_items = fixture_table(
102
 
    Table('order_items', fixture_metadata,
103
 
          Column('item_id', None, ForeignKey('items.id')),
104
 
          Column('order_id', None, ForeignKey('orders.id')),
105
 
          test_needs_acid=True,
106
 
          test_needs_fk=True),
107
 
    ('item_id', 'order_id'),
108
 
    (1, 1),
109
 
    (2, 1),
110
 
    (3, 1),
111
 
 
112
 
    (1, 2),
113
 
    (2, 2),
114
 
    (3, 2),
115
 
 
116
 
    (3, 3),
117
 
    (4, 3),
118
 
    (5, 3),
119
 
 
120
 
    (1, 4),
121
 
    (5, 4),
122
 
 
123
 
    (5, 5))
124
 
 
125
 
keywords = fixture_table(
126
 
    Table('keywords', fixture_metadata,
127
 
          Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
128
 
          Column('name', String(30), nullable=False),
129
 
          test_needs_acid=True,
130
 
          test_needs_fk=True),
131
 
    ('id', 'name'),
132
 
    (1, 'blue'),
133
 
    (2, 'red'),
134
 
    (3, 'green'),
135
 
    (4, 'big'),
136
 
    (5, 'small'),
137
 
    (6, 'round'),
138
 
    (7, 'square'))
139
 
 
140
 
item_keywords = fixture_table(
141
 
    Table('item_keywords', fixture_metadata,
142
 
          Column('item_id', None, ForeignKey('items.id')),
143
 
          Column('keyword_id', None, ForeignKey('keywords.id')),
144
 
          test_needs_acid=True,
145
 
          test_needs_fk=True),
146
 
    ('keyword_id', 'item_id'),
147
 
    (2, 1),
148
 
    (2, 2),
149
 
    (4, 1),
150
 
    (6, 1),
151
 
    (5, 2),
152
 
    (3, 3),
153
 
    (4, 3),
154
 
    (7, 2),
155
 
    (6, 3))
156
 
 
157
 
nodes = fixture_table(
158
 
    Table('nodes', fixture_metadata,
159
 
        Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
160
 
        Column('parent_id', Integer, ForeignKey('nodes.id')),
161
 
        Column('data', String(30)),
162
 
        test_needs_acid=True,
163
 
        test_needs_fk=True
164
 
    ),
165
 
    ('id', 'parent_id', 'data')
166
 
)
167
 
 
168
 
composite_pk_table = fixture_table(
169
 
    Table('composite_pk_table', fixture_metadata,
170
 
        Column('i', Integer, primary_key=True),
171
 
        Column('j', Integer, primary_key=True),
172
 
        Column('k', Integer, nullable=False),
173
 
    ),
174
 
    ('i', 'j', 'k'),
175
 
    (1, 2, 3),
176
 
    (2, 1, 4),
177
 
    (1, 1, 5),
178
 
    (2, 2,6))
179
 
 
180
 
 
181
 
def _load_fixtures():
182
 
    for table in fixture_metadata.sorted_tables:
183
 
        table.info[('fixture', 'loader')]()
184
 
 
185
 
def run_inserts_for(table, bind=None):
186
 
    table.info[('fixture', 'loader')](bind)
187
 
 
188
 
class Base(_base.ComparableEntity):
189
 
    pass
190
 
 
191
 
 
192
 
class User(Base):
193
 
    pass
194
 
 
195
 
 
196
 
class Order(Base):
197
 
    pass
198
 
 
199
 
 
200
 
class Item(Base):
201
 
    pass
202
 
 
203
 
 
204
 
class Keyword(Base):
205
 
    pass
206
 
 
207
 
 
208
 
class Address(Base):
209
 
    pass
210
 
 
211
 
 
212
 
class Dingaling(Base):
213
 
    pass
214
 
 
215
 
 
216
 
class Node(Base):
217
 
    pass
218
 
 
219
 
class CompositePk(Base):
220
 
    pass
221
 
 
222
 
class FixtureTest(_base.MappedTest):
223
 
    """A MappedTest pre-configured for fixtures.
224
 
 
225
 
    All fixture tables are pre-loaded into cls.tables, as are all fixture
226
 
    lasses in cls.classes and as cls.ClassName.
227
 
 
228
 
    Fixture.mapper() still functions and willregister non-fixture classes into
229
 
    cls.classes.
 
10
 
 
11
class FixtureTest(fixtures.MappedTest):
 
12
    """A MappedTest pre-configured with a common set of fixtures.
230
13
 
231
14
    """
232
15
 
236
19
    run_inserts = 'each'
237
20
    run_deletes = 'each'
238
21
 
239
 
    metadata = fixture_metadata
240
 
    fixture_classes = dict(User=User,
241
 
                           Order=Order,
242
 
                           Item=Item,
243
 
                           Keyword=Keyword,
244
 
                           Address=Address,
245
 
                           Dingaling=Dingaling)
 
22
    @classmethod
 
23
    def setup_classes(cls):
 
24
        class Base(cls.Comparable):
 
25
            pass
 
26
 
 
27
        class User(Base):
 
28
            pass
 
29
 
 
30
        class Order(Base):
 
31
            pass
 
32
 
 
33
        class Item(Base):
 
34
            pass
 
35
 
 
36
        class Keyword(Base):
 
37
            pass
 
38
 
 
39
        class Address(Base):
 
40
            pass
 
41
 
 
42
        class Dingaling(Base):
 
43
            pass
 
44
 
 
45
        class Node(Base):
 
46
            pass
 
47
 
 
48
        class CompositePk(Base):
 
49
            pass
246
50
 
247
51
    @classmethod
248
52
    def define_tables(cls, metadata):
249
 
        pass
250
 
 
251
 
    @classmethod
252
 
    def setup_classes(cls):
253
 
        for cl in cls.fixture_classes.values():
254
 
            cls.register_class(cl)
 
53
        Table('users', metadata,
 
54
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
55
              Column('name', String(30), nullable=False),
 
56
              test_needs_acid=True,
 
57
              test_needs_fk=True
 
58
        )
 
59
 
 
60
        Table('addresses', metadata,
 
61
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
62
              Column('user_id', None, ForeignKey('users.id')),
 
63
              Column('email_address', String(50), nullable=False),
 
64
              test_needs_acid=True,
 
65
              test_needs_fk=True
 
66
        )
 
67
 
 
68
        Table('email_bounces', metadata,
 
69
              Column('id', Integer, ForeignKey('addresses.id')),
 
70
              Column('bounces', Integer)
 
71
        )
 
72
 
 
73
        Table('orders', metadata,
 
74
                  Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
75
                  Column('user_id', None, ForeignKey('users.id')),
 
76
                  Column('address_id', None, ForeignKey('addresses.id')),
 
77
                  Column('description', String(30)),
 
78
                  Column('isopen', Integer),
 
79
                  test_needs_acid=True,
 
80
                  test_needs_fk=True
 
81
        )
 
82
 
 
83
        Table("dingalings", metadata,
 
84
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
85
              Column('address_id', None, ForeignKey('addresses.id')),
 
86
              Column('data', String(30)),
 
87
              test_needs_acid=True,
 
88
              test_needs_fk=True
 
89
        )
 
90
 
 
91
        Table('items', metadata,
 
92
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
93
              Column('description', String(30), nullable=False),
 
94
              test_needs_acid=True,
 
95
              test_needs_fk=True
 
96
        )
 
97
 
 
98
        Table('order_items', metadata,
 
99
              Column('item_id', None, ForeignKey('items.id')),
 
100
              Column('order_id', None, ForeignKey('orders.id')),
 
101
              test_needs_acid=True,
 
102
              test_needs_fk=True
 
103
        )
 
104
 
 
105
        Table('keywords', metadata,
 
106
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
107
              Column('name', String(30), nullable=False),
 
108
              test_needs_acid=True,
 
109
              test_needs_fk=True
 
110
        )
 
111
 
 
112
        Table('item_keywords', metadata,
 
113
              Column('item_id', None, ForeignKey('items.id')),
 
114
              Column('keyword_id', None, ForeignKey('keywords.id')),
 
115
              test_needs_acid=True,
 
116
              test_needs_fk=True
 
117
        )
 
118
 
 
119
        Table('nodes', metadata,
 
120
            Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
 
121
            Column('parent_id', Integer, ForeignKey('nodes.id')),
 
122
            Column('data', String(30)),
 
123
            test_needs_acid=True,
 
124
            test_needs_fk=True
 
125
        )
 
126
 
 
127
        Table('composite_pk_table', metadata,
 
128
            Column('i', Integer, primary_key=True),
 
129
            Column('j', Integer, primary_key=True),
 
130
            Column('k', Integer, nullable=False),
 
131
        )
255
132
 
256
133
    @classmethod
257
134
    def setup_mappers(cls):
258
135
        pass
259
136
 
260
137
    @classmethod
261
 
    def insert_data(cls):
262
 
        _load_fixtures()
263
 
 
 
138
    def fixtures(cls):
 
139
        return dict(
 
140
            users = (
 
141
                ('id', 'name'),
 
142
                (7, 'jack'),
 
143
                (8, 'ed'),
 
144
                (9, 'fred'),
 
145
                (10, 'chuck')
 
146
            ),
 
147
 
 
148
            addresses = (
 
149
                ('id', 'user_id', 'email_address'),
 
150
                (1, 7, "jack@bean.com"),
 
151
                (2, 8, "ed@wood.com"),
 
152
                (3, 8, "ed@bettyboop.com"),
 
153
                (4, 8, "ed@lala.com"),
 
154
                (5, 9, "fred@fred.com")
 
155
            ),
 
156
 
 
157
            email_bounces = (
 
158
                ('id', 'bounces'),
 
159
                (1, 1),
 
160
                (2, 0),
 
161
                (3, 5),
 
162
                (4, 0),
 
163
                (5, 0)
 
164
            ),
 
165
 
 
166
            orders = (
 
167
                ('id', 'user_id', 'description', 'isopen', 'address_id'),
 
168
                (1, 7, 'order 1', 0, 1),
 
169
                (2, 9, 'order 2', 0, 4),
 
170
                (3, 7, 'order 3', 1, 1),
 
171
                (4, 9, 'order 4', 1, 4),
 
172
                (5, 7, 'order 5', 0, None)
 
173
            ),
 
174
 
 
175
            dingalings = (
 
176
                ('id', 'address_id', 'data'),
 
177
                (1, 2, 'ding 1/2'),
 
178
                (2, 5, 'ding 2/5')
 
179
            ),
 
180
 
 
181
            items = (
 
182
                ('id', 'description'),
 
183
                (1, 'item 1'),
 
184
                (2, 'item 2'),
 
185
                (3, 'item 3'),
 
186
                (4, 'item 4'),
 
187
                (5, 'item 5')
 
188
            ),
 
189
 
 
190
            order_items = (
 
191
                ('item_id', 'order_id'),
 
192
                (1, 1),
 
193
                (2, 1),
 
194
                (3, 1),
 
195
 
 
196
                (1, 2),
 
197
                (2, 2),
 
198
                (3, 2),
 
199
 
 
200
                (3, 3),
 
201
                (4, 3),
 
202
                (5, 3),
 
203
 
 
204
                (1, 4),
 
205
                (5, 4),
 
206
 
 
207
                (5, 5)
 
208
            ),
 
209
 
 
210
            keywords = (
 
211
                ('id', 'name'),
 
212
                (1, 'blue'),
 
213
                (2, 'red'),
 
214
                (3, 'green'),
 
215
                (4, 'big'),
 
216
                (5, 'small'),
 
217
                (6, 'round'),
 
218
                (7, 'square')
 
219
            ),
 
220
 
 
221
            item_keywords = (
 
222
                ('keyword_id', 'item_id'),
 
223
                (2, 1),
 
224
                (2, 2),
 
225
                (4, 1),
 
226
                (6, 1),
 
227
                (5, 2),
 
228
                (3, 3),
 
229
                (4, 3),
 
230
                (7, 2),
 
231
                (6, 3)
 
232
            ),
 
233
 
 
234
            nodes = (
 
235
                ('id', 'parent_id', 'data')
 
236
            ),
 
237
 
 
238
            composite_pk_table = (
 
239
                ('i', 'j', 'k'),
 
240
                (1, 2, 3),
 
241
                (2, 1, 4),
 
242
                (1, 1, 5),
 
243
                (2, 2,6)
 
244
            )
 
245
        )
 
246
 
 
247
    @util.memoized_property
 
248
    def static(self):
 
249
        return CannedResults(self)
264
250
 
265
251
class CannedResults(object):
266
252
    """Built on demand, instances use mappers in effect at time of call."""
267
253
 
 
254
    def __init__(self, test):
 
255
        self.test = test
 
256
 
268
257
    @property
269
258
    def user_result(self):
 
259
        User = self.test.classes.User
 
260
 
270
261
        return [
271
262
            User(id=7),
272
263
            User(id=8),
275
266
 
276
267
    @property
277
268
    def user_address_result(self):
 
269
        User, Address = self.test.classes.User, self.test.classes.Address
 
270
 
278
271
        return [
279
272
            User(id=7, addresses=[
280
273
                Address(id=1)
291
284
 
292
285
    @property
293
286
    def user_all_result(self):
 
287
        User, Address, Order, Item = self.test.classes.User, \
 
288
            self.test.classes.Address, self.test.classes.Order, \
 
289
            self.test.classes.Item
 
290
 
294
291
        return [
295
292
            User(id=7,
296
293
                 addresses=[
325
322
 
326
323
    @property
327
324
    def user_order_result(self):
 
325
        User, Order, Item = self.test.classes.User, \
 
326
            self.test.classes.Order, self.test.classes.Item
328
327
        return [
329
328
            User(id=7,
330
329
                 orders=[
358
357
 
359
358
    @property
360
359
    def item_keyword_result(self):
 
360
        Item, Keyword = self.test.classes.Item, self.test.classes.Keyword
361
361
        return [
362
362
            Item(id=1,
363
363
                 keywords=[
381
381
 
382
382
    @property
383
383
    def user_item_keyword_result(self):
 
384
        Item, Keyword = self.test.classes.Item, self.test.classes.Keyword
 
385
        User, Order = self.test.classes.User, self.test.classes.Order
 
386
 
384
387
        item1, item2, item3, item4, item5 = \
385
388
             Item(id=1,
386
389
                  keywords=[
421
424
                User(id=10, orders=[])]
422
425
        return user_result
423
426
 
424
 
FixtureTest.static = CannedResults()
425
427