← Back to branch summary

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

« back to all changes in this revision

Viewing changes to test/orm/inheritance/test_concrete.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/inheritance/test_concrete.py
1
 
from sqlalchemy.test.testing import eq_, assert_raises, \
 
1
from test.lib.testing import eq_, assert_raises, \
2
2
    assert_raises_message
3
3
from sqlalchemy import *
4
4
from sqlalchemy.orm import *
5
5
from sqlalchemy.orm import exc as orm_exc
6
 
from sqlalchemy.test import *
 
6
from test.lib import *
7
7
import sqlalchemy as sa
8
 
from sqlalchemy.test import testing
9
 
from test.orm import _base
 
8
from test.lib import testing
 
9
from test.lib import fixtures
10
10
from sqlalchemy.orm import attributes
11
 
from sqlalchemy.test.testing import eq_
12
 
from sqlalchemy.test.schema import Table, Column
 
11
from test.lib.testing import eq_
 
12
from test.lib.schema import Table, Column
13
13
 
14
14
 
15
15
class Employee(object):
64
64
    pass
65
65
 
66
66
 
67
 
class ConcreteTest(_base.MappedTest):
 
67
class ConcreteTest(fixtures.MappedTest):
68
68
 
69
69
    @classmethod
70
70
    def define_tables(cls, metadata):
372
372
        self.assert_sql_count(testing.db, go, 1)
373
373
 
374
374
 
375
 
class PropertyInheritanceTest(_base.MappedTest):
 
375
class PropertyInheritanceTest(fixtures.MappedTest):
376
376
 
377
377
    @classmethod
378
378
    def define_tables(cls, metadata):
397
397
    @classmethod
398
398
    def setup_classes(cls):
399
399
 
400
 
        class A(_base.ComparableEntity):
 
400
        class A(cls.Comparable):
401
401
            pass
402
402
 
403
403
        class B(A):
406
406
        class C(A):
407
407
            pass
408
408
 
409
 
        class Dest(_base.ComparableEntity):
 
409
        class Dest(cls.Comparable):
410
410
            pass
411
411
 
412
 
    @testing.resolve_artifact_names
413
412
    def test_noninherited_warning(self):
 
413
        A, B, b_table, a_table, Dest, dest_table = (self.classes.A,
 
414
                                self.classes.B,
 
415
                                self.tables.b_table,
 
416
                                self.tables.a_table,
 
417
                                self.classes.Dest,
 
418
                                self.tables.dest_table)
 
419
 
414
420
        mapper(A, a_table, properties={'some_dest': relationship(Dest)})
415
421
        mapper(B, b_table, inherits=A, concrete=True)
416
422
        mapper(Dest, dest_table)
430
436
        mapper(B, b_table, inherits=A, concrete=True)
431
437
        mapper(Dest, dest_table)
432
438
 
433
 
    @testing.resolve_artifact_names
434
439
    def test_inheriting(self):
 
440
        A, B, b_table, a_table, Dest, dest_table = (self.classes.A,
 
441
                                self.classes.B,
 
442
                                self.tables.b_table,
 
443
                                self.tables.a_table,
 
444
                                self.classes.Dest,
 
445
                                self.tables.dest_table)
 
446
 
435
447
        mapper(A, a_table, properties={
436
448
                'some_dest': relationship(Dest,back_populates='many_a')
437
449
            })
464
476
        assert dest1.many_b == [b1, b2]
465
477
        assert sess.query(B).filter(B.bname == 'b1').one() is b1
466
478
 
467
 
    @testing.resolve_artifact_names
468
479
    def test_polymorphic_backref(self):
469
480
        """test multiple backrefs to the same polymorphically-loading
470
481
        attribute."""
471
482
 
 
483
        A, C, B, c_table, b_table, a_table, Dest, dest_table = (self.classes.A,
 
484
                                self.classes.C,
 
485
                                self.classes.B,
 
486
                                self.tables.c_table,
 
487
                                self.tables.b_table,
 
488
                                self.tables.a_table,
 
489
                                self.classes.Dest,
 
490
                                self.tables.dest_table)
 
491
 
 
492
 
472
493
        ajoin = polymorphic_union({'a': a_table, 'b': b_table, 'c':c_table}, 
473
494
                                'type','ajoin')
474
495
        mapper(
543
564
 
544
565
        self.assert_sql_count(testing.db, go, 1)
545
566
 
546
 
    @testing.resolve_artifact_names
547
567
    def test_merge_w_relationship(self):
 
568
        A, C, B, c_table, b_table, a_table, Dest, dest_table = (self.classes.A,
 
569
                                self.classes.C,
 
570
                                self.classes.B,
 
571
                                self.tables.c_table,
 
572
                                self.tables.b_table,
 
573
                                self.tables.a_table,
 
574
                                self.classes.Dest,
 
575
                                self.tables.dest_table)
 
576
 
548
577
        ajoin = polymorphic_union({'a': a_table, 'b': b_table, 'c':c_table}, 
549
578
                                'type','ajoin')
550
579
        mapper(
602
631
        eq_(merged_c1.some_dest.name, 'd2')
603
632
        eq_(merged_c1.some_dest_id, c1.some_dest_id)
604
633
 
605
 
class ManyToManyTest(_base.MappedTest):
 
634
class ManyToManyTest(fixtures.MappedTest):
606
635
 
607
636
    @classmethod
608
637
    def define_tables(cls, metadata):
622
651
              primary_key=True, test_needs_autoincrement=True))
623
652
 
624
653
    @classmethod
625
 
    @testing.resolve_artifact_names
626
654
    def setup_classes(cls):
627
 
        class Base(_base.ComparableEntity):
 
655
        class Base(cls.Comparable):
628
656
            pass
629
657
 
630
658
        class Sub(Base):
631
659
            pass
632
660
 
633
 
        class Related(_base.ComparableEntity):
 
661
        class Related(cls.Comparable):
634
662
            pass
635
663
 
636
664
 
637
 
    @testing.resolve_artifact_names
638
665
    def test_selective_relationships(self):
 
666
        sub, base_mtom, Related, Base, related, sub_mtom, base, Sub = (self.tables.sub,
 
667
                                self.tables.base_mtom,
 
668
                                self.classes.Related,
 
669
                                self.classes.Base,
 
670
                                self.tables.related,
 
671
                                self.tables.sub_mtom,
 
672
                                self.tables.base,
 
673
                                self.classes.Sub)
 
674
 
639
675
        mapper(Base, base, properties={'related': relationship(Related,
640
676
               secondary=base_mtom, backref='bases',
641
677
               order_by=related.c.id)})
657
693
        eq_(b1.related, [r1, r2])
658
694
 
659
695
 
660
 
class ColKeysTest(_base.MappedTest):
 
696
class ColKeysTest(fixtures.MappedTest):
661
697
 
662
698
    @classmethod
663
699
    def define_tables(cls, metadata):