root / elixir / trunk / tests / test_abstract.py @ 512

Revision 512, 5.4 kB (checked in by ged, 5 years ago)

- allows abstract classes to set default options
- allow mixed type inheritance (classes can inherit from a concrete class and

abstract classes at the same time).

- cleaned up slightly the abstract patch

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
Line 
1"""
2test inheritance with abstract entities
3"""
4
5import re
6
7from elixir import *
8import elixir
9
10def camel_to_underscore(entity):
11    return re.sub(r'(.+?)([A-Z])+?', r'\1_\2', entity.__name__).lower()
12
13def setup():
14    metadata.bind = 'sqlite://'
15    elixir.options_defaults['shortnames'] = True
16
17class TestAbstractInheritance(object):
18    def teardown(self):
19        cleanup_all(True)
20
21    def test_abstract_alone(self):
22        class AbstractPerson(Entity):
23            using_options(abstract=True)
24
25            firstname = Field(String(30))
26            lastname = Field(String(30))
27
28        setup_all(True)
29
30        assert not hasattr(AbstractPerson, 'table')
31
32    def test_inheritance(self):
33        class AbstractPerson(Entity):
34            using_options(abstract=True)
35
36            firstname = Field(String(30))
37            lastname = Field(String(30))
38
39        class AbstractEmployed(AbstractPerson):
40            using_options(abstract=True)
41
42            corporation = Field(String(30))
43
44        class Employed(AbstractEmployed):
45            service = Field(String(30))
46
47        class Citizen(AbstractPerson):
48            country = Field(String(30))
49
50        setup_all(True)
51
52        assert not hasattr(AbstractPerson, 'table')
53        assert not hasattr(AbstractEmployed, 'table')
54        assert hasattr(Employed, 'table')
55        assert hasattr(Citizen, 'table')
56
57        assert 'firstname' in Employed.table.columns
58        assert 'lastname' in Employed.table.columns
59        assert 'corporation' in Employed.table.columns
60        assert 'service' in Employed.table.columns
61
62        assert 'firstname' in Citizen.table.columns
63        assert 'lastname' in Citizen.table.columns
64        assert 'corporation' not in Citizen.table.columns
65        assert 'country' in Citizen.table.columns
66
67    def test_simple_relation(self):
68        class Page(Entity):
69            title = Field(String(30))
70            content = Field(String(30))
71            comments = OneToMany('Comment')
72
73        class AbstractAttachment(Entity):
74            using_options(abstract=True)
75
76            page = ManyToOne('Page')
77            is_spam = Field(Boolean())
78
79        class Comment(AbstractAttachment):
80            message = Field(String(100))
81
82        setup_all(True)
83
84        p1 = Page(title="My title", content="My content")
85        p1.comments.append(Comment(message='My first comment', is_spam=False))
86
87        assert p1.comments[0].page == p1
88        session.commit()
89
90    def test_simple_relation_abstract_wh_multiple_children(self):
91        class Page(Entity):
92            title = Field(String(30))
93            content = Field(String(30))
94            comments = OneToMany('Comment')
95            links = OneToMany('Link')
96
97        class AbstractAttachment(Entity):
98            using_options(abstract=True)
99
100            page = ManyToOne('Page')
101            is_spam = Field(Boolean())
102
103        class Link(AbstractAttachment):
104            url = Field(String(30))
105
106        class Comment(AbstractAttachment):
107            message = Field(String(100))
108
109        setup_all(True)
110
111        p1 = Page(title="My title", content="My content")
112        p1.comments.append(Comment(message='My first comment', is_spam=False))
113        p1.links.append(Link(url="My url", is_spam=True))
114
115        assert p1.comments[0].page == p1
116        session.commit()
117
118    def test_multiple_inheritance(self):
119        class AbstractDated(Entity):
120            using_options(abstract=True)
121            using_options_defaults(tablename=camel_to_underscore)
122
123            #TODO: add defaults
124            created_date = Field(DateTime)
125            modified_date = Field(DateTime)
126
127        class AbstractContact(Entity):
128            using_options(abstract=True)
129            using_options_defaults(identity=camel_to_underscore)
130
131            first_name = Field(Unicode(50))
132            last_name = Field(Unicode(50))
133
134        class DatedContact(AbstractContact, AbstractDated):
135            pass
136
137        setup_all(True)
138
139        assert 'created_date' in DatedContact.table.columns
140        assert 'modified_date' in DatedContact.table.columns
141        assert 'first_name' in DatedContact.table.columns
142        assert 'last_name' in DatedContact.table.columns
143        assert DatedContact._descriptor.identity == 'dated_contact'
144        assert DatedContact.table.name == 'dated_contact'
145
146        contact1 = DatedContact(first_name=u"Guido", last_name=u"van Rossum")
147        session.commit()
148
149    def test_mixed_inheritance(self):
150        class AbstractDated(Entity):
151            using_options(abstract=True)
152            using_options_defaults(tablename=camel_to_underscore)
153
154            #TODO: add defaults
155            created_date = Field(DateTime)
156            modified_date = Field(DateTime)
157
158        class AbstractContact(Entity):
159            using_options(abstract=True)
160            using_options_defaults(identity=camel_to_underscore)
161
162            first_name = Field(Unicode(50))
163            last_name = Field(Unicode(50))
164
165        class Contact(AbstractContact):
166            using_options(inheritance='multi')
167
168        class DatedContact(AbstractDated, Contact):
169            using_options(inheritance='multi')
170
171        setup_all(True)
172
173        assert 'created_date' in DatedContact.table.columns
174        assert 'modified_date' in DatedContact.table.columns
175        assert DatedContact._descriptor.identity == 'dated_contact'
176        assert DatedContact.table.name == 'dated_contact'
177
178        contact1 = DatedContact(first_name=u"Guido", last_name=u"van Rossum")
179        session.commit()
Note: See TracBrowser for help on using the browser.