← 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
  • Date: 2013-10-28 22:29:40 UTC
  • mfrom: (1.4.24)
  • Revision ID: package-import@ubuntu.com-20131028222940-wvyqffl4g617caun
Tags: 0.8.3-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/ext/test_associationproxy.py
9
9
from sqlalchemy.ext.associationproxy import _AssociationList
10
10
from sqlalchemy.testing import assert_raises_message
11
11
from sqlalchemy.testing.util import gc_collect
12
 
from sqlalchemy.sql import not_
13
12
from sqlalchemy.testing import fixtures, AssertsCompiledSQL
14
13
from sqlalchemy import testing
15
14
from sqlalchemy.testing.schema import Table, Column
139
138
        self.assert_(len(p1._children) == 0)
140
139
        self.assert_(len(p1.children) == 0)
141
140
 
142
 
        p1.children = ['a','b','c']
 
141
        p1.children = ['a', 'b', 'c']
143
142
        self.assert_(len(p1._children) == 3)
144
143
        self.assert_(len(p1.children) == 3)
145
144
 
324
323
        self.assert_(len(p1._children) == 3)
325
324
        self.assert_(len(p1.children) == 3)
326
325
 
327
 
        self.assert_(set(p1.children) == set(['d','e','f']))
 
326
        self.assert_(set(p1.children) == set(['d', 'e', 'f']))
328
327
 
329
328
        del ch
330
329
        p1 = self.roundtrip(p1)
407
406
        self.assert_(len(p1._children) == 0)
408
407
        self.assert_(len(p1.children) == 0)
409
408
 
410
 
        p1.children = ['a','b','c']
 
409
        p1.children = ['a', 'b', 'c']
411
410
        self.assert_(len(p1._children) == 3)
412
411
        self.assert_(len(p1.children) == 3)
413
412
 
421
420
        self.assert_('b' in p1.children)
422
421
        self.assert_('d' not in p1.children)
423
422
 
424
 
        self.assert_(p1.children == set(['a','b','c']))
 
423
        self.assert_(p1.children == set(['a', 'b', 'c']))
425
424
 
426
 
        try:
427
 
            p1.children.remove('d')
428
 
            self.fail()
429
 
        except KeyError:
430
 
            pass
 
425
        assert_raises(
 
426
            KeyError,
 
427
            p1.children.remove, "d"
 
428
        )
431
429
 
432
430
        self.assert_(len(p1.children) == 3)
433
431
        p1.children.discard('d')
442
440
        self.assert_(len(p1.children) == 2)
443
441
        self.assert_(popped not in p1.children)
444
442
 
445
 
        p1.children = ['a','b','c']
 
443
        p1.children = ['a', 'b', 'c']
446
444
        p1 = self.roundtrip(p1)
447
 
        self.assert_(p1.children == set(['a','b','c']))
 
445
        self.assert_(p1.children == set(['a', 'b', 'c']))
448
446
 
449
447
        p1.children.discard('b')
450
448
        p1 = self.roundtrip(p1)
476
474
        Parent, Child = self.Parent, self.Child
477
475
 
478
476
        p1 = Parent('P1')
479
 
        p1.children = ['a','b','c']
480
 
        control = set(['a','b','c'])
 
477
        p1.children = ['a', 'b', 'c']
 
478
        control = set(['a', 'b', 'c'])
481
479
 
482
 
        for other in (set(['a','b','c']), set(['a','b','c','d']),
483
 
                      set(['a']), set(['a','b']),
484
 
                      set(['c','d']), set(['e', 'f', 'g']),
 
480
        for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
 
481
                      set(['a']), set(['a', 'b']),
 
482
                      set(['c', 'd']), set(['e', 'f', 'g']),
485
483
                      set()):
486
484
 
487
485
            eq_(p1.children.union(other),
499
497
            eq_(p1.children.issuperset(other),
500
498
                             control.issuperset(other))
501
499
 
502
 
            self.assert_((p1.children == other)  ==  (control == other))
503
 
            self.assert_((p1.children != other)  ==  (control != other))
504
 
            self.assert_((p1.children < other)   ==  (control < other))
505
 
            self.assert_((p1.children <= other)  ==  (control <= other))
506
 
            self.assert_((p1.children > other)   ==  (control > other))
507
 
            self.assert_((p1.children >= other)  ==  (control >= other))
 
500
            self.assert_((p1.children == other) == (control == other))
 
501
            self.assert_((p1.children != other) == (control != other))
 
502
            self.assert_((p1.children < other) == (control < other))
 
503
            self.assert_((p1.children <= other) == (control <= other))
 
504
            self.assert_((p1.children > other) == (control > other))
 
505
            self.assert_((p1.children >= other) == (control >= other))
508
506
 
509
507
    def test_set_mutation(self):
510
508
        Parent, Child = self.Parent, self.Child
513
511
        for op in ('update', 'intersection_update',
514
512
                   'difference_update', 'symmetric_difference_update'):
515
513
            for base in (['a', 'b', 'c'], []):
516
 
                for other in (set(['a','b','c']), set(['a','b','c','d']),
517
 
                              set(['a']), set(['a','b']),
518
 
                              set(['c','d']), set(['e', 'f', 'g']),
 
514
                for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
 
515
                              set(['a']), set(['a', 'b']),
 
516
                              set(['c', 'd']), set(['e', 'f', 'g']),
519
517
                              set()):
520
518
                    p = Parent('p')
521
519
                    p.children = base[:]
544
542
        # in-place mutations
545
543
        for op in ('|=', '-=', '&=', '^='):
546
544
            for base in (['a', 'b', 'c'], []):
547
 
                for other in (set(['a','b','c']), set(['a','b','c','d']),
548
 
                              set(['a']), set(['a','b']),
549
 
                              set(['c','d']), set(['e', 'f', 'g']),
 
545
                for other in (set(['a', 'b', 'c']), set(['a', 'b', 'c', 'd']),
 
546
                              set(['a']), set(['a', 'b']),
 
547
                              set(['c', 'd']), set(['e', 'f', 'g']),
550
548
                              frozenset(['e', 'f', 'g']),
551
549
                              set()):
552
550
                    p = Parent('p')
599
597
 
600
598
        # We didn't provide an alternate _AssociationList implementation
601
599
        # for our ObjectCollection, so indexing will fail.
 
600
        assert_raises(
 
601
            TypeError,
 
602
            p.children.__getitem__, 1
 
603
        )
602
604
 
603
 
        try:
604
 
            v = p.children[1]
605
 
            self.fail()
606
 
        except TypeError:
607
 
            pass
608
605
 
609
606
class ProxyFactoryTest(ListTest):
610
607
    def setup(self):
719
716
        p = Parent('p')
720
717
 
721
718
        # No child
722
 
        try:
723
 
            v = p.foo
724
 
            self.fail()
725
 
        except:
726
 
            pass
 
719
        assert_raises(
 
720
            AttributeError,
 
721
            getattr, p, "foo"
 
722
        )
727
723
 
728
724
        p.child = Child(foo='a', bar='b', baz='c')
729
725
 
745
741
        p.child = None
746
742
 
747
743
        # No child again
748
 
        try:
749
 
            v = p.foo
750
 
            self.fail()
751
 
        except:
752
 
            pass
 
744
        assert_raises(
 
745
            AttributeError,
 
746
            getattr, p, "foo"
 
747
        )
753
748
 
754
749
        # Bogus creator for this scalar type
755
 
        try:
756
 
            p.foo = 'zzz'
757
 
            self.fail()
758
 
        except TypeError:
759
 
            pass
 
750
        assert_raises(
 
751
            TypeError,
 
752
            setattr, p, "foo", "zzz"
 
753
        )
760
754
 
761
755
        p.bar = 'yyy'
762
756
 
840
834
                                  collection_class=list)})
841
835
 
842
836
        p = Parent('p')
843
 
        p.children = ['a','b','c']
 
837
        p.children = ['a', 'b', 'c']
844
838
 
845
839
        p = self.roundtrip(p)
846
840
 
858
852
                                  collection_class=list)})
859
853
 
860
854
        p = Parent('p')
861
 
        p.children = ['a','b','c']
 
855
        p.children = ['a', 'b', 'c']
862
856
 
863
857
        p = self.roundtrip(p)
864
858
 
1024
1018
    @classmethod
1025
1019
    def define_tables(cls, metadata):
1026
1020
        Table('userkeywords', metadata,
1027
 
          Column('keyword_id', Integer,ForeignKey('keywords.id'), primary_key=True),
 
1021
          Column('keyword_id', Integer, ForeignKey('keywords.id'), primary_key=True),
1028
1022
          Column('user_id', Integer, ForeignKey('users.id'))
1029
1023
        )
1030
1024
        Table('users', metadata,
1089
1083
                                cls.classes.Singular)
1090
1084
 
1091
1085
        mapper(User, users, properties={
1092
 
            'singular':relationship(Singular)
 
1086
            'singular': relationship(Singular)
1093
1087
        })
1094
1088
        mapper(Keyword, keywords, properties={
1095
 
            'user_keyword':relationship(UserKeyword, uselist=False)
 
1089
            'user_keyword': relationship(UserKeyword, uselist=False)
1096
1090
        })
1097
1091
 
1098
1092
        mapper(UserKeyword, userkeywords, properties={
1099
 
            'user' : relationship(User, backref='user_keywords'),
1100
 
            'keyword' : relationship(Keyword)
 
1093
            'user': relationship(User, backref='user_keywords'),
 
1094
            'keyword': relationship(Keyword)
1101
1095
        })
1102
1096
        mapper(Singular, singular, properties={
1103
1097
            'keywords': relationship(Keyword)
1204
1198
 
1205
1199
        self._equivalent(
1206
1200
            self.session.query(User).\
1207
 
                        filter(User.singular_keywords.any(Keyword.keyword=='jumped')),
 
1201
                        filter(User.singular_keywords.any(Keyword.keyword == 'jumped')),
1208
1202
            self.session.query(User).\
1209
1203
                        filter(
1210
1204
                            User.singular.has(
1211
 
                                Singular.keywords.any(Keyword.keyword=='jumped')
 
1205
                                Singular.keywords.any(Keyword.keyword == 'jumped')
1212
1206
                            )
1213
1207
                        )
1214
1208
        )
1254
1248
    def test_filter_eq_null_nul_nul(self):
1255
1249
        UserKeyword, Keyword = self.classes.UserKeyword, self.classes.Keyword
1256
1250
 
1257
 
        self._equivalent(self.session.query(Keyword).filter(Keyword.user
1258
 
                         == None),
1259
 
                         self.session.query(Keyword).
1260
 
                            filter(Keyword.user_keyword.has(UserKeyword.user
1261
 
                         == None)))
 
1251
        self._equivalent(
 
1252
                self.session.query(Keyword).filter(Keyword.user == None),
 
1253
                self.session.query(Keyword).
 
1254
                   filter(Keyword.user_keyword.has(UserKeyword.user == None)))
1262
1255
 
1263
1256
    def test_filter_scalar_contains_fails_nul_nul(self):
1264
1257
        Keyword = self.classes.Keyword
1265
1258
 
1266
 
        assert_raises(exc.InvalidRequestError, lambda : \
1267
 
                      Keyword.user.contains(self.u))
 
1259
        assert_raises(exc.InvalidRequestError,
 
1260
                lambda: Keyword.user.contains(self.u))
1268
1261
 
1269
1262
    def test_filter_scalar_any_fails_nul_nul(self):
1270
1263
        Keyword = self.classes.Keyword
1271
1264
 
1272
 
        assert_raises(exc.InvalidRequestError, lambda : \
1273
 
                      Keyword.user.any(name='user2'))
 
1265
        assert_raises(exc.InvalidRequestError,
 
1266
                lambda: Keyword.user.any(name='user2'))
1274
1267
 
1275
1268
    def test_filter_collection_has_fails_ul_nul(self):
1276
1269
        User = self.classes.User
1277
1270
 
1278
 
        assert_raises(exc.InvalidRequestError, lambda : \
1279
 
                      User.keywords.has(keyword='quick'))
 
1271
        assert_raises(exc.InvalidRequestError,
 
1272
                lambda: User.keywords.has(keyword='quick'))
1280
1273
 
1281
1274
    def test_filter_collection_eq_fails_ul_nul(self):
1282
1275
        User = self.classes.User
1283
1276
 
1284
 
        assert_raises(exc.InvalidRequestError, lambda : \
1285
 
                      User.keywords == self.kw)
 
1277
        assert_raises(exc.InvalidRequestError,
 
1278
                lambda: User.keywords == self.kw)
1286
1279
 
1287
1280
    def test_filter_collection_ne_fails_ul_nul(self):
1288
1281
        User = self.classes.User
1289
1282
 
1290
 
        assert_raises(exc.InvalidRequestError, lambda : \
1291
 
                      User.keywords != self.kw)
 
1283
        assert_raises(exc.InvalidRequestError,
 
1284
                lambda: User.keywords != self.kw)
1292
1285
 
1293
1286
    def test_join_separate_attr(self):
1294
1287
        User = self.classes.User
1330
1323
        b = Table('b', m, Column('id', Integer, primary_key=True),
1331
1324
                    Column('aid', Integer, ForeignKey('a.id')))
1332
1325
        mapper(A, a, properties={
1333
 
            'orig':relationship(B, collection_class=attribute_mapped_collection('key'))
 
1326
            'orig': relationship(B, collection_class=attribute_mapped_collection('key'))
1334
1327
        })
1335
1328
        mapper(B, b)
1336
1329
        self.A = A
1339
1332
    def test_update_one_elem_dict(self):
1340
1333
        a1 = self.A()
1341
1334
        a1.elements.update({("B", 3): 'elem2'})
1342
 
        eq_(a1.elements, {("B",3):'elem2'})
 
1335
        eq_(a1.elements, {("B", 3): 'elem2'})
1343
1336
 
1344
1337
    def test_update_multi_elem_dict(self):
1345
1338
        a1 = self.A()
1346
1339
        a1.elements.update({("B", 3): 'elem2', ("C", 4): "elem3"})
1347
 
        eq_(a1.elements, {("B",3):'elem2', ("C", 4): "elem3"})
 
1340
        eq_(a1.elements, {("B", 3): 'elem2', ("C", 4): "elem3"})
1348
1341
 
1349
1342
    def test_update_one_elem_list(self):
1350
1343
        a1 = self.A()
1351
1344
        a1.elements.update([(("B", 3), 'elem2')])
1352
 
        eq_(a1.elements, {("B",3):'elem2'})
 
1345
        eq_(a1.elements, {("B", 3): 'elem2'})
1353
1346
 
1354
1347
    def test_update_multi_elem_list(self):
1355
1348
        a1 = self.A()
1356
1349
        a1.elements.update([(("B", 3), 'elem2'), (("C", 4), "elem3")])
1357
 
        eq_(a1.elements, {("B",3):'elem2', ("C", 4): "elem3"})
 
1350
        eq_(a1.elements, {("B", 3): 'elem2', ("C", 4): "elem3"})
1358
1351
 
1359
1352
    def test_update_one_elem_varg(self):
1360
1353
        a1 = self.A()