Changeset 470

Show
Ignore:
Timestamp:
09/25/09 18:11:59 (4 years ago)
Author:
ged
Message:

rewrote all autoload tests so that they pass on SA 0.6 and they are not as much
interdependant

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • elixir/trunk/tests/test_autoload.py

    r461 r470  
    33""" 
    44 
    5 from sqlalchemy import Table, Column, ForeignKey, MetaData 
     5from sqlalchemy import Table, Column, ForeignKey 
    66from elixir import * 
    77import elixir 
    … …  
    1818 
    1919def setup(): 
    20     # First create the tables 
    21     meta = MetaData('sqlite://') 
    22  
    23     person_table = Table('person', meta, 
    24         Column('id', Integer, primary_key=True), 
    25         Column('father_id', Integer, ForeignKey('person.id')), 
    26         Column('name', String(32))) 
    27  
    28     animal_table = Table('animal', meta, 
    29         Column('id', Integer, primary_key=True), 
    30         Column('name', String(30)), 
    31         Column('owner_id', Integer, ForeignKey('person.id')), 
    32         Column('feeder_id', Integer, ForeignKey('person.id'))) 
    33  
    34     category_table = Table('category', meta, 
    35         Column('name', String(30), primary_key=True)) 
    36  
    37     person_category_table = Table('person_category', meta, 
    38         Column('person_id', Integer, ForeignKey('person.id')), 
    39         Column('category_name', String(30), ForeignKey('category.name'))) 
    40  
    41     person_person_table = Table('person_person', meta, 
    42         Column('person_id1', Integer, ForeignKey('person.id')), 
    43         Column('person_id2', Integer, ForeignKey('person.id'))) 
    44  
    45     meta.create_all() 
    46  
    4720    elixir.options_defaults.update(dict(autoload=True, shortnames=True)) 
    4821 
    49     global Person, Animal, Category 
    50  
    51     #TODO: split these into individual classes for each test. 
    52     class Person(Entity): 
    53         father = ManyToOne('Person') 
    54         children = OneToMany('Person') 
    55         pets = OneToMany('Animal', inverse='owner') 
    56         animals = OneToMany('Animal', inverse='feeder') 
    57         categories = ManyToMany('Category', 
    58                                 tablename='person_category') 
    59         appreciate = ManyToMany('Person', 
    60                                 tablename='person_person', 
    61                                 local_colname='person_id1') 
    62         isappreciatedby = ManyToMany('Person', 
    63                                 tablename='person_person', 
    64                                 local_colname='person_id2') 
    65  
    66     class Animal(Entity): 
    67         owner = ManyToOne('Person', colname='owner_id') 
    68         feeder = ManyToOne('Person', colname='feeder_id') 
    69  
    70  
    71     class Category(Entity): 
    72         persons = ManyToMany('Person', 
    73                                 tablename='person_category') 
    74  
    75     metadata.bind = meta.bind 
    76     setup_all() 
    77  
    78  
    7922def teardown(): 
    80     cleanup_all() 
    8123    elixir.options_defaults.update(dict(autoload=False, shortnames=False)) 
    8224 
    … …  
    8527class TestAutoload(object): 
    8628    def setup(self): 
    87         create_all() 
     29        metadata.bind = 'sqlite://' 
    8830 
    8931    def teardown(self): 
    90         drop_all() 
    91         session.clear() 
     32        cleanup_all(True) 
    9233 
    9334    def test_simple(self): 
     35        person_table = Table('person', metadata, 
     36            Column('id', Integer, primary_key=True), 
     37            Column('name', String(32))) 
     38 
     39        animal_table = Table('animal', metadata, 
     40            Column('id', Integer, primary_key=True), 
     41            Column('name', String(30)), 
     42            Column('owner_id', Integer, ForeignKey('person.id')), 
     43            Column('feeder_id', Integer, ForeignKey('person.id'))) 
     44 
     45        metadata.create_all() 
     46 
     47        class Person(Entity): 
     48            pets = OneToMany('Animal', inverse='owner') 
     49            animals = OneToMany('Animal', inverse='feeder') 
     50 
     51        class Animal(Entity): 
     52            owner = ManyToOne('Person', colname='owner_id') 
     53            feeder = ManyToOne('Person', colname='feeder_id') 
     54 
     55        setup_all() 
     56 
    9457        snowball = Animal(name="Snowball II") 
    9558        slh = Animal(name="Santa's Little Helper") 
    … …  
    10972 
    11073    def test_selfref(self): 
     74        person_table = Table('person', metadata, 
     75            Column('id', Integer, primary_key=True), 
     76            Column('father_id', Integer, ForeignKey('person.id')), 
     77            Column('name', String(32))) 
     78        metadata.create_all() 
     79 
     80        class Person(Entity): 
     81            father = ManyToOne('Person') 
     82            children = OneToMany('Person') 
     83 
     84        setup_all() 
     85 
    11186        grampa = Person(name="Abe") 
    11287        homer = Person(name="Homer") 
    … …  
    129104 
    130105    def test_m2m(self): 
     106        person_table = Table('person', metadata, 
     107            Column('id', Integer, primary_key=True), 
     108            Column('name', String(32))) 
     109 
     110        category_table = Table('category', metadata, 
     111            Column('name', String(30), primary_key=True)) 
     112 
     113        person_category_table = Table('person_category', metadata, 
     114            Column('person_id', Integer, ForeignKey('person.id')), 
     115            Column('category_name', String(30), ForeignKey('category.name'))) 
     116 
     117        metadata.create_all() 
     118 
     119        class Person(Entity): 
     120            categories = ManyToMany('Category', 
     121                                    tablename='person_category') 
     122 
     123        class Category(Entity): 
     124            persons = ManyToMany('Person', 
     125                                 tablename='person_category') 
     126 
     127        setup_all() 
     128 
    131129        stupid = Category(name="Stupid") 
    132130        simpson = Category(name="Simpson") 
    … …  
    150148 
    151149    def test_m2m_selfref(self): 
     150        person_table = Table('person', metadata, 
     151            Column('id', Integer, primary_key=True), 
     152            Column('name', String(32))) 
     153 
     154        person_person_table = Table('person_person', metadata, 
     155            Column('person_id1', Integer, ForeignKey('person.id')), 
     156            Column('person_id2', Integer, ForeignKey('person.id'))) 
     157 
     158        metadata.create_all() 
     159 
     160        class Person(Entity): 
     161            appreciate = ManyToMany('Person', 
     162                                    tablename='person_person', 
     163                                    local_colname='person_id1') 
     164            isappreciatedby = ManyToMany('Person', 
     165                                         tablename='person_person', 
     166                                         local_colname='person_id2') 
     167 
     168        setup_all() 
     169 
    152170        barney = Person(name="Barney") 
    153171        homer = Person(name="Homer", appreciate=[barney]) 
    … …  
    165183    # overrides tests 
    166184    # ---------------- 
     185    def _create_table_a(self): 
     186        a_table = Table('a', metadata, 
     187            Column('id', Integer, primary_key=True), 
     188            Column('name', String(32))) 
     189 
     190        metadata.create_all() 
    167191 
    168192    def test_override_pk_fails(self): 
    169         class Person(Entity): 
     193        self._create_table_a() 
     194 
     195        class A(Entity): 
    170196            id = Field(Integer, primary_key=True) 
    171197 
    172         setup_entity_raise(Person) 
     198        setup_entity_raise(A) 
    173199 
    174200    def test_override_non_pk_fails(self): 
    175         class Animal(Entity): 
     201        self._create_table_a() 
     202 
     203        class A(Entity): 
    176204            name = Field(String(30)) 
    177205 
    178         setup_entity_raise(Animal) 
     206        setup_entity_raise(A) 
    179207 
    180208    def test_override_pk(self): 
    181         class Person(Entity): 
     209        self._create_table_a() 
     210 
     211        class A(Entity): 
    182212            using_options(allowcoloverride=True) 
    183213 
    184214            id = Field(Integer, primary_key=True) 
    185215 
    186         setup_entities([Person]) 
     216        setup_entities([A]) 
    187217 
    188218    def test_override_non_pk(self): 
    189         class Animal(Entity): 
     219        self._create_table_a() 
     220 
     221        class A(Entity): 
    190222            using_options(allowcoloverride=True) 
    191223 
    192224            name = Field(String(30)) 
    193225 
    194         setup_entities([Animal]) 
    195         assert isinstance(Animal.table.columns['name'].type, String) 
    196  
    197     # ---------------- 
     226        setup_entities([A]) 
     227        assert isinstance(A.table.columns['name'].type, String) 
     228 
     229    # --------------- 
    198230 
    199231    def test_nopk(self): 
    200         metadata.bind = 'sqlite://' 
    201  
    202         local_meta = MetaData(metadata.bind) 
    203  
    204         table = Table('a', local_meta, 
     232        table = Table('a', metadata, 
    205233            Column('id', Integer), 
    206234            Column('name', String(32))) 
    207235 
    208         local_meta.create_all() 
     236        metadata.create_all() 
    209237 
    210238        class A(Entity): 
    … …  
    224252 
    225253    def test_inheritance(self): 
    226         metadata.bind = 'sqlite://' 
    227  
    228         local_meta = MetaData(metadata.bind) 
    229  
    230         table = Table('father', local_meta, 
     254        table = Table('father', metadata, 
    231255            Column('id', Integer, primary_key=True), 
    232256            Column('row_type', elixir.options.POLYMORPHIC_COL_TYPE)) 
    233257 
    234         local_meta.create_all() 
     258        metadata.create_all() 
    235259 
    236260        class Father(Entity):