← Back to branch summary

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

« back to all changes in this revision

Viewing changes to test/ext/test_associationproxy.py

  • Committer: Package Import Robot
  • Author(s): Piotr Ożarowski, Jakub Wilk, Piotr Ożarowski
  • Date: 2013-07-06 20:53:52 UTC
  • mfrom: (1.4.23) (16.1.17 experimental)
  • Revision ID: package-import@ubuntu.com-20130706205352-ryppl1eto3illd79
Tags: 0.8.2-1
[ Jakub Wilk ]
* Use canonical URIs for Vcs-* fields.

[ Piotr Ożarowski ]
* New upstream release
* Upload to unstable
* Build depend on python3-all instead of -dev, extensions are not built for
  Python 3.X 

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/ext/test_associationproxy.py
1
 
from test.lib.testing import eq_, assert_raises
 
1
from sqlalchemy.testing import eq_, assert_raises
2
2
import copy
3
3
import pickle
4
4
 
7
7
from sqlalchemy.orm.collections import collection, attribute_mapped_collection
8
8
from sqlalchemy.ext.associationproxy import *
9
9
from sqlalchemy.ext.associationproxy import _AssociationList
10
 
from test.lib import *
11
 
from test.lib.testing import assert_raises_message
12
 
from test.lib.util import gc_collect
 
10
from sqlalchemy.testing import assert_raises_message
 
11
from sqlalchemy.testing.util import gc_collect
13
12
from sqlalchemy.sql import not_
14
 
from test.lib import fixtures
15
 
 
 
13
from sqlalchemy.testing import fixtures, AssertsCompiledSQL
 
14
from sqlalchemy import testing
 
15
from sqlalchemy.testing.schema import Table, Column
16
16
 
17
17
class DictCollection(dict):
18
18
    @collection.appender
971
971
        p.kids.extend(['c1', 'c2'])
972
972
        r1 = pickle.loads(pickle.dumps(p))
973
973
        assert r1.kids == ['c1', 'c2']
974
 
        r2 = pickle.loads(pickle.dumps(p.kids))
975
 
        assert r2 == ['c1', 'c2']
 
974
 
 
975
        # can't do this without parent having a cycle
 
976
        #r2 = pickle.loads(pickle.dumps(p.kids))
 
977
        #assert r2 == ['c1', 'c2']
976
978
 
977
979
    def test_pickle_set(self):
978
980
        mapper(Parent, self.parents,
983
985
        p.kids.update(['c1', 'c2'])
984
986
        r1 = pickle.loads(pickle.dumps(p))
985
987
        assert r1.kids == set(['c1', 'c2'])
986
 
        r2 = pickle.loads(pickle.dumps(p.kids))
987
 
        assert r2 == set(['c1', 'c2'])
 
988
 
 
989
        # can't do this without parent having a cycle
 
990
        #r2 = pickle.loads(pickle.dumps(p.kids))
 
991
        #assert r2 == set(['c1', 'c2'])
988
992
 
989
993
    def test_pickle_dict(self):
990
994
        mapper(Parent, self.parents,
997
1001
        assert p.kids == {'c1': 'c1', 'c2': 'c2'}
998
1002
        r1 = pickle.loads(pickle.dumps(p))
999
1003
        assert r1.kids == {'c1': 'c1', 'c2': 'c2'}
1000
 
        r2 = pickle.loads(pickle.dumps(p.kids))
1001
 
        assert r2 == {'c1': 'c1', 'c2': 'c2'}
 
1004
 
 
1005
        # can't do this without parent having a cycle
 
1006
        #r2 = pickle.loads(pickle.dumps(p.kids))
 
1007
        #assert r2 == {'c1': 'c1', 'c2': 'c2'}
1002
1008
 
1003
1009
class PickleKeyFunc(object):
1004
1010
    def __init__(self, name):
1257
1263
    def test_filter_scalar_contains_fails_nul_nul(self):
1258
1264
        Keyword = self.classes.Keyword
1259
1265
 
1260
 
        assert_raises(exceptions.InvalidRequestError, lambda : \
 
1266
        assert_raises(exc.InvalidRequestError, lambda : \
1261
1267
                      Keyword.user.contains(self.u))
1262
1268
 
1263
1269
    def test_filter_scalar_any_fails_nul_nul(self):
1264
1270
        Keyword = self.classes.Keyword
1265
1271
 
1266
 
        assert_raises(exceptions.InvalidRequestError, lambda : \
 
1272
        assert_raises(exc.InvalidRequestError, lambda : \
1267
1273
                      Keyword.user.any(name='user2'))
1268
1274
 
1269
1275
    def test_filter_collection_has_fails_ul_nul(self):
1270
1276
        User = self.classes.User
1271
1277
 
1272
 
        assert_raises(exceptions.InvalidRequestError, lambda : \
 
1278
        assert_raises(exc.InvalidRequestError, lambda : \
1273
1279
                      User.keywords.has(keyword='quick'))
1274
1280
 
1275
1281
    def test_filter_collection_eq_fails_ul_nul(self):
1276
1282
        User = self.classes.User
1277
1283
 
1278
 
        assert_raises(exceptions.InvalidRequestError, lambda : \
 
1284
        assert_raises(exc.InvalidRequestError, lambda : \
1279
1285
                      User.keywords == self.kw)
1280
1286
 
1281
1287
    def test_filter_collection_ne_fails_ul_nul(self):
1282
1288
        User = self.classes.User
1283
1289
 
1284
 
        assert_raises(exceptions.InvalidRequestError, lambda : \
 
1290
        assert_raises(exc.InvalidRequestError, lambda : \
1285
1291
                      User.keywords != self.kw)
1286
1292
 
1287
1293
    def test_join_separate_attr(self):